﻿using Mono.CompilerServices.SymbolWriter;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;

namespace Teal.Compiler {

    #region MemberDefinition

    /// <summary>
    /// 表示一个成员（如方法、字段、类型、包等）定义。
    /// </summary>
    public abstract partial class MemberDefinition {

        #region 暂时不能删除

        public virtual bool Define() {
            return true;
        }

        //
        // Holds all attributes attached to this element
        //
        public MemberAnnotationList attributes;

        //public void AddAttributes(MemberAnnotationList attrs, IMemberContext context) {
        //    if (attrs == null)
        //        return;

        //    if (attributes == null)
        //        attributes = attrs;
        //    else
        //        attributes.AddAttributes(attrs.Attrs);

        //    attrs.AttachTo(this, context);
        //}

        public MemberAnnotationList OptAttributes {
            get {
                return attributes;
            }
        }

        /// <summary>
        /// Use member-specific procedure to apply attribute @a in @cb to the entity being built in @builder
        /// </summary>
        public abstract void ApplyAttributeBuilder(MemberAnnotation a, MethodReference ctor, byte[] cdata, PredefinedAttributes pa);

        string Iname {
            get {
                return member_name.Name;
            }
        }

        // Is not readonly because of IndexerName attribute
        private MemberName member_name;
        public MemberName MemberName {
            get { return member_name; }
        }

        public Modifiers ModFlags {
            set {
                modifiers = value;
                if ((value & Modifiers.COMPILER_GENERATED) != 0)
                    caching_flags = Flags2.IsUsed | Flags2.IsAssigned;
            }
            get {
                return modifiers;
            }
        }

        /// <summary>
        ///   Location where this declaration happens
        /// </summary>
        public Location2 startLocation2 {
            get { return member_name.Location; }
        }

        public virtual string GetSignatureForError() {
            return reference.signature;
        }


        /// <summary>
        /// Base Emit method. This is also entry point for CLS-Compliant verification.
        /// </summary>
        public virtual void Emit() {
        }

        #endregion

        #region 父级成员

        /// <summary>
        /// 获取包含当前成员的容器。
        /// </summary>
        public MemberContainerDefinition container;

        /// <summary>
        /// 获取包含当前成员的类。
        /// </summary>
        public TypeDefinition containerType {
            get {
                return container as TypeDefinition;
            }
        }

        /// <summary>
        /// 获取包含当前成员定义的源单元。
        /// </summary>
        public SourceUnit containerSourceUnit {
            get {
                var c = this;
                do {
                    var p = c as SourceUnit;
                    if (p != null) {
                        return p;
                    }
                } while ((c = c.container) != null);
                return null;
            }
        }

        /// <summary>
        /// 获取包含当前成员定义的模块。
        /// </summary>
        public ModuleDefinition containerModule {
            get {
                var c = this;
                do {
                    var p = c as ModuleDefinition;
                    if (p != null) {
                        return p;
                    }
                } while ((c = c.container) != null);
                return null;
            }
        }

        #endregion

        #region 语义解析

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public MemberReference reference;

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected abstract MemberType memberType { get; }

        /// <summary>
        /// 创建当前成员对应的引用。
        /// </summary>
        public abstract void defineMember();

        /// <summary>
        /// 解析所有类型的基类型。
        /// </summary>
        public abstract void resolveBaseTypes();

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public abstract void resolveMember();

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public abstract void resolveBody();

        #endregion

        #region 成员定义

        /// <summary>
        /// 将当前成员引用添加到父容器。
        /// </summary>
        protected void addReferenceToContainer() {

            var member = reference;
            var c = container.reference;

            // 绑定源。
            member.definition = this;

            // 在容器添加成员。
            var exist = c.addMember(member);

            // 除了方法重载，不允许出现同名且有相同泛型参数个数的成员。
            if (exist != null && (member.memberType != exist.memberType || !exist.memberType.isOverloadable())) {
                for (var arity = member.genericParameterCount; exist != member; exist = exist.next) {
                    if (exist.genericParameterCount == arity) {
                        Compiler.error(ErrorCode.none, String.Format(arity == 0 ? "{0}“{1}”已包含名为“{2}”的{3}定义" : "{0}“{1}”已包含名为“{2}”且具有相同泛型参数的{3}定义", c.memberType.getReadableName(), c.signature, name.value, exist.memberType.getReadableName()), name);
                        break;
                    }
                }
            }

            //  全局范围不需要检查成员名。
            if (c.memberType == MemberType.@namespace) {
                return;
            }

            string memberName = member.name;

            // 不能和所属类型名相同。
            if (c.name == memberName) {
                Compiler.error(ErrorCode.none, String.Format("“{0}”：成员名不能和所在类型相同", memberName), name);
                return;
            }

            // 不能和所属类型的泛型参数相同。
            if (c.getGenericParameter(memberName) != null) {
                Compiler.error(ErrorCode.none, String.Format("“{0}”：成员名不能和所在类型的泛型形参相同", memberName), name);
                return;
            }
        }

        /// <summary>
        /// 向用户报告某个成员的错误。
        /// </summary>
        /// <param name="errorCode"></param>
        /// <param name="message"></param>
        protected void reportMemberError(ErrorCode errorCode, string message) {
            Compiler.error(errorCode, String.Format("“{0}”：{1}", reference.signature, message), name);
        }

        #endregion

        #region 注解

        /// <summary>
        /// 表示一个注解。
        /// </summary>
        public partial class MemberAnnotation {

            /// <summary>
            /// 获取当前注解解析后的目标注解类型。
            /// </summary>
            public TypeReference resolvedTargetType;

            /// <summary>
            /// 获取当前注解解析后的构造函数调用表达式。
            /// </summary>
            public ResolvedMethodInvocationExpression resolvedTarget;

        }

        /// <summary>
        /// 解析当前成员的所有注解类型。
        /// </summary>
        protected void resolveAnnotations() {
            for (var annotation = annotations; annotation != null; annotation = annotation.next) {

                // 解析类型。
                var resolvedTarget = annotation.target.resolveAsMember(this, MemberUsage.annotation);
                if (resolvedTarget == null) {
                    continue;
                }

                // 注解必须是类。
                if (resolvedTarget.memberType != MemberType.@class) {
                    Compiler.error(ErrorCode.none, String.Format("注解必须是类；无法使用{0}“{1}”注解", resolvedTarget.memberType.getReadableName(), resolvedTarget.signature), this);
                    continue;
                }

                var resolved = annotation.resolvedTargetType = (TypeReference)resolvedTarget;

                // 注解不能是静态或抽象类。
                if (resolved.modifiers.hasFlag(Modifiers.@static | Modifiers.@abstract)) {
                    if (resolved.modifiers.hasFlag(Modifiers.@static)) {
                        Compiler.error(ErrorCode.none, String.Format("无法使用静态类“{0}”注解", resolved.signature), annotation.target);
                    } else {
                        Compiler.error(ErrorCode.none, String.Format("无法使用抽象类“{0}”注解", resolved.signature), annotation.target);
                    }
                    continue;
                }

                // 注解不能是泛型类。
                if (resolved.isGeneric) {
                    Compiler.error(ErrorCode.none, String.Format("无法使用泛型类“{0}”注解", resolved.signature), annotation.target);
                    continue;
                }

            }
        }

        /// <summary>
        /// 检查注解类型是否合法。
        /// </summary>
        protected void checkAnnotations() {
            for (var annotation = annotations; annotation != null; annotation = annotation.next) {
                var resolvedTargetType = annotation.resolvedTargetType;

                resolvedTargetType.checkType(annotation.target);

                //// 注解不能是否定成员。
                //ResolveHelper.checkDeprecated(resolvedTargetType, annotation.target);

                // 检查应用成员和重复性。
                bool allowMultiple = false;

                //// 如果此注解类型定义了 annotationUsage, 则执行判断。
                //var annotationUsageData = (AnnotationUsageData)resolvedTargetType.getPredefinedAnnotation(PredefinedTypes.System_AnnotationUsageAnnotation);
                //if (annotationUsageData != null) {

                //    Debug.Assert(annotationUsageData != AnnotationUsageData.uninitialized);

                //    // 检查注解的目标类型是否适用于当前成员。
                //    if (!annotationUsageData.target.HasFlag(reference.memberType)) {
                //        Compiler.error(ErrorCode.none, String.Format("注解“{0}”不能应用于{1}", resolvedTargetType.signature, reference.memberType.getReadableName()), annotation.target);
                //        continue;
                //    }

                //    allowMultiple = annotationUsageData.allowMultiple;
                //}

                if (!allowMultiple) {
                    for (var annotation2 = annotations; annotation2 != annotation; annotation2 = annotation2.next) {
                        if (annotation2.resolvedTargetType == resolvedTargetType) {
                            Compiler.error(ErrorCode.none, String.Format("注解“{0}”重复", annotation2.resolvedType.signature), annotation2.target);
                            break;
                        }
                    }
                }

                // 解析注解参数。
                //var resolvedTarget = annotation.resolvedTarget = ResolveHelper.invoke(ResolveHelper.createResolveContext(this), resolvedTargetType.getAllConstrutors(), null, annotation.arguments, annotation);

                //// 注解参数必须全部是常量。
                //if (resolvedTarget != null) {
                //    for (var argument = annotation.arguments; argument != null; argument = argument.next) {
                //        if (!(argument.resolvedValue is Constant)) {
                //            Compiler.error(ErrorCode.none, "注解参数必须是常量", argument.value);
                //        }
                //    }
                //}


                checkAnnotation(annotation);

            }
        }

        /// <summary>
        /// 当被子类重写时，负责检查特定的注解。
        /// </summary>
        protected virtual void checkAnnotation(MemberAnnotation annotation) { }

        /// <summary>
        /// 获取指定类型的注解。
        /// </summary>
        /// <param name="annotationType"></param>
        /// <returns></returns>
        public MemberAnnotation getAnnotation(TypeReference annotationType) {
            for (var annotation = annotations; annotation != null; annotation = annotation.next) {
                if (annotation.resolvedTargetType == annotationType) {
                    return annotation;
                }
            }
            return null;
        }

        #endregion

        #region 修饰符

        /// <summary>
        /// 检查指定类型成员是否包含不允许的修饰符。
        /// </summary>
        /// <param name="unexpectedModifiers">允许的修饰符。</param>
        /// <param name="memberName">提示时使用的成员类型名。</param>
        protected void checkUnexpectedModifiers(Modifiers unexpectedModifiers, string memberName) {

            // 检查是否有不符合要求的修饰符。
            int unexpectedModifierValue = (int)(modifiers & unexpectedModifiers);
            if (unexpectedModifierValue == 0) {
                return;
            }

            // 计算所有不合要求的修饰符。
            int currentModifier = 1;
            string unexpectedModifiersString = null;
            while (unexpectedModifierValue > 0) {
                if ((unexpectedModifierValue & 1) == 1) {
                    if (unexpectedModifiersString != null) {
                        unexpectedModifiersString += "、";
                    }
                    unexpectedModifiersString += "“" + ((Modifiers)currentModifier).getName() + "”";
                }
                unexpectedModifierValue >>= 1;
                currentModifier <<= 1;
            }

            Compiler.error(ErrorCode.invalidModifiers, String.Format("“{0}”：修饰符{1}对{2}无效；应删除{1}修饰符", reference.signature, unexpectedModifiersString, memberName), name);
        }

        /// <summary>
        /// 获取当前成员的修饰符。如果当前修饰符未包含访问修饰符，根据成员名字自动设置。
        /// </summary>
        protected Modifiers getModifiersWithDefaultAccessibility() {
            return modifiers.getAccessibility() == Modifiers.none && name.value.Length > 0 && name.value[0] == '_' ? (modifiers | Modifiers.@private) : modifiers;
        }

        /// <summary>
        /// 检测 new 修饰符是否正确使用。
        /// </summary>
        protected void checkNew() {
            MemberReference baseMember;
            var parentType = reference.containerType;
            if (parentType != null && parentType.baseClass != null && (baseMember = parentType.baseClass.getOverrideingMember(reference)) != null && !baseMember.modifiers.hasFlag(Modifiers.@private)) {
                if (baseMember.modifiers.hasFlag(Modifiers.@abstract)) {
                    Compiler.error(ErrorCode.none, String.Format("“{0}”覆盖了继承的抽象成员“{1}”", reference.signature, baseMember.signature), name);
                } else if (!modifiers.hasFlag(Modifiers.@new)) {
                    Compiler.warning(ErrorCode.none, String.Format("“{0}”覆盖了继承的成员“{1}”；如果是有意覆盖，请添加“new”修饰符", reference.signature, baseMember.signature), name);
                }
            } else if (modifiers.hasFlag(Modifiers.@new)) {
                Compiler.warning(ErrorCode.none, String.Format("“{0}”并未覆盖继承的成员，不需要“new”修饰符", reference.signature), name);
            }
        }

        #endregion

        #region 泛型

        /// <summary>
        /// 创建泛型形参的引用。
        /// </summary>
        /// <param name="genericParameters">要处理的泛型形参。</param>
        /// <returns></returns>
        protected MemberReference.GenericParameter[] defineGenericParameters(GenericParameter genericParameters) {

            // 统计泛型形参个数。
            var genericParameterCount = 0;
            for (var genericParameter = genericParameters; genericParameter != null; genericParameter = genericParameter.next) {
                genericParameterCount++;

                // 形参包含 ...，则返回动态形参数。
                if (genericParameter.name == null) {
                    return PredefinedTypes.argListParameters;
                }
            }

            var result = new MemberReference.GenericParameter[genericParameterCount];

            var i = 0;
            for (var genericParameter = genericParameters; genericParameter != null; genericParameter = genericParameter.next, i++) {

                var p = result[i] = new MemberReference.GenericParameter();
                var n = p.name = genericParameter.name.value;
                p.index = i;

                if (n == name.value) {
                    Compiler.error(ErrorCode.none, String.Format("“{0}”：泛型形参名不能和所在成员相同", n), genericParameter);
                    continue;
                }

                for (int j = 0; j < i; j++) {
                    if (result[j].name == n) {
                        Compiler.error(ErrorCode.none, String.Format("当前{0}已经包含名为“{1}”的泛型参数", memberType.getReadableName(), n), genericParameter.name);
                        break;
                    }
                }

                var t = container.reference;
                while (t != null) {
                    if (t.getGenericParameter(n) != null) {
                        Compiler.warning(ErrorCode.none, String.Format("“{0}”：内嵌类型的泛型参数和所在类型相同", n));
                        break;
                    }
                    t = t.container;
                }

            }

            return result;
        }

        /// <summary>
        /// 解析当前泛型定义的泛型形参。
        /// </summary>
        /// 
        /// <param name="genericParameters">要处理的泛型形参。</param>
        protected void resolveGenericParameters(GenericParameter genericParameters) {
            if (genericParameters == null) {
                return;
            }
            var i = 0;
            var gps = reference.genericParameters;
            for (var genericParameter = genericParameters; genericParameter != null; genericParameter = genericParameter.next, i++) {
                var gp = gps[i];

                // 解析泛型约束。
                resolveBaseTypes(MemberType.typeParameter, gp, genericParameter.constraints);

                // 设置默认约束基类。
                if (gp.baseClass == null) {
                    gp.baseClass = PredefinedTypes.System_Object;
                }

            }
        }

        /// <summary>
        /// 解析泛型参数类型以及类型约束。
        /// </summary>
        protected void checkGenericParameters(GenericParameter genericParameters) {
            if (genericParameters == null) {
                return;
            }
            var gps = reference.genericParameters;
            var i = 0;
            for (var genericParameter = genericParameters; genericParameter != null; genericParameter = genericParameter.next, i++) {
                checkBaseTypes(MemberType.typeParameter, gps[i], genericParameter.constraints);
            }
        }

        #endregion

        #region 基类型

        /// <summary>
        /// 解析基类或泛型约束。
        /// </summary>
        /// <param name="memberType">当前成员的成员类型。可能为：class、struct、interface、enum、extension、typeParameter</param>
        /// <param name="target">解析的目标类型。</param>
        /// <param name="baseTypes">源基类型列表。</param>
        protected void resolveBaseTypes(MemberType memberType, TypeReference target, List<Expression> baseTypes) {

            if (baseTypes == null) {
                return;
            }

            Debug.Assert(target != null);

            for (var i = 0; i < baseTypes.Count; i++) {

                // 解析基类。
                var baseType = baseTypes[i];
                var resolved = baseType.resolveAsType(this, MemberUsage.baseType);
                if (resolved == null) {
                    continue;
                }

                // 检查基类访问性。
                if (!resolved.isAccessibleAs(target)) {
                    if (memberType == MemberType.typeParameter) {
                        Compiler.error(ErrorCode.none, String.Format("“{3}”：泛型参数“{0}”的基{1}约束“{2}”的访问权限不能低于成员本身", target.signature, resolved.memberType.getReadableName(), resolved.signature, reference.signature), baseType);
                    } else {
                        Compiler.error(ErrorCode.none, String.Format("“{0}”：基{1}“{2}”的访问权限不能低于类型本身", target.signature, resolved.memberType.getReadableName(), resolved.signature), baseType);
                    }
                    continue;
                }

                switch (resolved.memberType) {
                    case MemberType.@class:

                        // 只能继承非静态、最终类。
                        if (resolved.modifiers.hasFlag(Modifiers.final | Modifiers.@static)) {
                            if (resolved.modifiers.hasFlag(Modifiers.final)) {
                                if (memberType == MemberType.typeParameter) {
                                    Compiler.error(ErrorCode.none, String.Format("“{2}”：泛型参数“{0}”无法使用最终类“{1}”约束", target.signature, resolved.signature, reference.signature), baseType);
                                } else {
                                    Compiler.error(ErrorCode.none, String.Format("“{0}”：无法从最终类“{1}”继承", target.signature, resolved.signature), baseType);
                                }
                            } else {
                                if (memberType == MemberType.typeParameter) {
                                    Compiler.error(ErrorCode.none, String.Format("“{2}”：泛型参数“{0}”无法使用静态类“{1}”约束", target.signature, resolved.signature, reference.signature), baseType);
                                } else {
                                    Compiler.error(ErrorCode.none, String.Format("“{0}”：无法从静态类“{1}”继承", target.signature, resolved.signature), baseType);
                                }
                            }
                            continue;
                        }

                        switch (memberType) {
                            case MemberType.@class:

                                // 无法多继承。
                                if (target.baseClass != null) {
                                    if (target.baseClass == resolved) {
                                        Compiler.error(ErrorCode.none, String.Format("“{0}”：类“{1}”已经包含在继承列表中", target.signature, resolved.signature), baseType);
                                    } else {
                                        Compiler.error(ErrorCode.none, String.Format("“{0}”不能同时继承“{1}”和“{2}”；类多继承不被支持，请使用接口代替", target.signature, target.baseClass.signature, resolved.signature), baseType);
                                    }
                                    continue;
                                }

                                // 必须先写基类，然后是基接口。
                                if (i > 0) {
                                    Compiler.error(ErrorCode.none, String.Format("“{0}”：基类“{1}”必须位于所有接口之前", target.signature, resolved.signature), baseType);
                                    continue;
                                }

                                target.baseClass = resolved;

                                // 检查循环继承关系。
                                // 不是当前项目内定义的类不存在循环继承的关系。
                                // 如果父类的父类还未解析完成，则不继续判断，等待解析父类时进行判断。
                                if (!checkCircleBaseClass(target.baseClass)) {
                                    Compiler.error(ErrorCode.none, String.Format("检测到“{0}”和“{1}”有基类循环继承依赖关系", reference.signature, target.baseClass.signature), baseType);

                                    // 删除循环引用，防止其它地方无法处理基类。
                                    target.baseClass = null;
                                }

                                break;

                            case MemberType.typeParameter:

                                // 必须先写基类约束，然后是基接口。
                                if (i > 0) {
                                    Compiler.error(ErrorCode.none, String.Format("“{2}”：泛型参数“{0}”的基类约束“{1}”必须位于所有其它约束之前", target.signature, resolved.signature, reference.signature), baseType);
                                    continue;
                                }

                                target.baseClass = resolved;

                                break;

                            case MemberType.@interface:
                                Compiler.error(ErrorCode.none, String.Format("“{0}”：接口只能从另一个接口继承；无法从{1}“{2}”继承", target.signature, resolved.memberType.getReadableName(), resolved.signature), baseType);
                                continue;

                            case MemberType.@struct:
                                Compiler.error(ErrorCode.none, String.Format("“{0}”：结构只能继承接口；无法从{1}“{2}”继承", target.signature, resolved.memberType.getReadableName(), resolved.signature), baseType);
                                continue;

                            case MemberType.@enum:
                                Compiler.error(ErrorCode.none, String.Format("“{0}”：枚举只能从常量类型继承；无法从{1}“{2}”继承", target.signature, resolved.memberType.getReadableName(), resolved.signature), baseType);
                                continue;

                            case MemberType.extension:
                                Compiler.error(ErrorCode.none, "只能静态扩展继承接口；无法静态扩展基类", baseType);
                                continue;

                            default:
                                throw new Unreachable();

                        }

                        break;
                    case MemberType.@interface:

                        if (memberType == MemberType.@enum) {
                            Compiler.error(ErrorCode.none, String.Format("“{0}”：枚举只能从常量类型继承；无法从{1}“{2}”继承", target.signature, resolved.memberType.getReadableName(), resolved.signature), baseType);
                            continue;
                        }

                        if (!target.addInterface(resolved)) {
                            if (memberType == MemberType.typeParameter) {
                                Compiler.error(ErrorCode.none, String.Format("“{2}”：接口“{1}”已经包含在泛型参数“{0}”的约束列表中", target.signature, resolved.signature, reference.signature), baseType);
                            } else {
                                Compiler.error(ErrorCode.none, String.Format("“{0}”：接口“{1}”已经包含在继承列表中", reference.signature, resolved.signature), baseType);
                            }
                            continue;
                        }

                        // 如果为接口添加接口，需判断循环继承。
                        if (target.memberType == MemberType.@interface && !checkCircleBaseInterface(resolved)) {
                            Compiler.error(ErrorCode.none, String.Format("检测到“{0}”和“{1}”有接口循环继承依赖关系", target.signature, resolved.signature), baseType);
                            //target.baseInterfaces.Remove(resolved);
                            continue;
                        }

                        break;
                    case MemberType.constraintType:
                        Debug.Assert(memberType == MemberType.typeParameter);

                        var tp = (MemberReference.GenericParameter)target;

                        if (resolved == PredefinedTypes.defaultConstructorConstraint) {
                            if ((tp.attributes & (MemberReference.GenericParameter.Attributes.structConstraint | MemberReference.GenericParameter.Attributes.enumConstraint)) != 0) {
                                Compiler.error(ErrorCode.none, "已约束为“struct”或“enum”时，不能再使用“new()”约束", baseType);
                                continue;
                            }
                            tp.attributes |= MemberReference.GenericParameter.Attributes.defaultConstructorConstraint;
                            break;
                        }

                        // 必须先写基类，然后是基接口。
                        if (i > 0) {
                            Compiler.error(ErrorCode.none, String.Format("“{2}”：泛型参数“{0}”的约束“{1}”必须位于所有基类约束之前", reference.signature, resolved.signature, resolved.signature), baseType);
                            continue;
                        }

                        if (resolved == PredefinedTypes.classConstraint) {
                            tp.attributes |= MemberReference.GenericParameter.Attributes.classConstraint;
                            target.baseClass = PredefinedTypes.System_Object;
                        } else if (resolved == PredefinedTypes.structConstraint) {
                            tp.attributes |= MemberReference.GenericParameter.Attributes.structConstraint;
                            target.baseClass = PredefinedTypes.System_ValueType;
                        } else {
                            tp.attributes |= MemberReference.GenericParameter.Attributes.enumConstraint;
                            target.baseClass = PredefinedTypes.System_ValueType;
                        }

                        break;
                    default:
                        if (memberType == MemberType.typeParameter) {
                            Compiler.error(ErrorCode.none, String.Format("“{3}”：泛型参数“{0}”无法从{1}“{2}”继承", target.signature, resolved.memberType.getReadableName(), resolved.signature, reference.signature), baseType);
                        } else {
                            Compiler.error(ErrorCode.none, String.Format("“{0}”：无法从{1}“{2}”继承", target.signature, resolved.memberType.getReadableName(), resolved.signature), baseType);
                        }
                        continue;
                }
            }
        }

        /// <summary>
        /// 检查当前成员是否存在循环继承关系。
        /// </summary>
        /// <returns></returns>
        private bool checkCircleBaseClass(TypeReference other) {

            // 检查泛型定义本身。
            other = other.genericDefinitionType;

            // 如果目标成员是外部导入的，则不会和当前对象有循环继承关系。
            if (other.definition == null) {
                return true;
            }

            // 如果经过多次基接口递归回到类型本身，表示有循环继承关系。
            if (other.definition == this) {
                return false;
            }

            var t = other.baseClass;
            if (t != null && !checkCircleBaseClass(t))
                return false;

            t = other.containerType;
            if (t != null && !checkCircleBaseClass(t))
                return false;

            return true;
        }

        private bool checkCircleBaseInterface(TypeReference other) {

            // 检查泛型定义本身。
            other = other.genericDefinitionType;

            // 如果目标成员是外部导入的，则不会和当前对象有循环继承关系。
            if (other.definition == null) {
                return true;
            }

            // 如果经过多次基接口递归回到类型本身，表示有循环继承关系。
            if (other.definition == this) {
                return false;
            }

            // 依次测试循环继承关系。
            var baseInterfaces = other.baseInterfaces;
            if (baseInterfaces != null) {
                for (int i = 0; i < baseInterfaces.Count; i++) {
                    if (!checkCircleBaseInterface(baseInterfaces[i])) {
                        return false;
                    }
                }
            }

            return true;
        }

        /// <summary>
        /// 检查基类完整性。
        /// </summary>
        protected void checkBaseTypes(MemberType memberType, TypeReference target, List<Expression> baseTypes) {

            if (baseTypes == null) {
                return;
            }

            Debug.Assert(target != null);

            var baseInterfaces = target.baseInterfaces;
            var baseTypeCount = baseInterfaces == null ? baseTypes.Count : (baseTypes.Count - baseInterfaces.Count);

            if (baseTypeCount > 0) {
                target.baseClass.checkType(baseTypes[0]);
            }

            if (baseInterfaces != null) {
                for (var i = 0; i < baseInterfaces.Count; i++) {
                    baseInterfaces[i].checkType(baseTypes[baseTypeCount++]);
                }
            }

        }

        #endregion

        #region 重写

        #endregion

    }

    #endregion

    #region TypeDefinitions

    /// <summary>
    /// 表示一个可以包含子成员的容器成员定义。
    /// </summary>
    public abstract partial class MemberContainerDefinition {

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public new NamespaceReference reference {
            get {
                return (NamespaceReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 创建当前成员对应的引用。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        [DebuggerStepThrough]
        public override void defineMember() {
            for (var member = members; member != null; member = member.next) {
                member.container = this;
                member.defineMember();
            }
        }

        /// <summary>
        /// 解析所有类型的基类型。
        /// </summary>
        [DebuggerStepThrough]
        public override void resolveBaseTypes() {
            for (var member = members; member != null; member = member.next) {
                member.resolveBaseTypes();
            }
        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        [DebuggerStepThrough]
        public override void resolveMember() {
            for (var member = members; member != null; member = member.next) {
                member.resolveMember();
            }
        }

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        [DebuggerStepThrough]
        public override void resolveBody() {
            for (var member = members; member != null; member = member.next) {
                member.resolveBody();
            }

            // 解析私有字段。
            checkFields();

        }

        /// <summary>
        /// 提示私有字段从未赋值。
        /// </summary>
        protected void checkFields() {
            for (MemberDefinition member = members; member != null; member = member.next) {
                var fieldDefinition = member as FieldDefinition;
                if (fieldDefinition == null) {
                    continue;
                }
                foreach (var field in fieldDefinition.references) {
                    // todo
                    //if (field.modifiers.hasFlag(Modifiers.@private) && !field.isEverUsed) {
                    //    if (field.isEverAssigned) {
                    //        Compiler.warning(ErrorCode.none, String.Format("字段“{0}”已赋值，但是从未使用", field.signature), field.variable.name);
                    //    } else {
                    //        Compiler.warning(ErrorCode.none, String.Format("字段“{0}”从未使用", field.signature), field.variable.name);
                    //    }
                    //}
                    // todo:字段从未赋值，它将始终是默认值。
                }
            }
        }

        /// <summary>
        /// 判断当前容器是否有显式布局。
        /// </summary>
        public bool hasExplictLayout {
            get {
                // .getAnnotation(PredefinedTypes.System_RunTime_StructLayoutAnnotation) != null /* && 且是 Explicit */
                return false;
            }
        }

    }

    /// <summary>
    /// 表示一个类型（如类、结构、接口）定义。
    /// </summary>
    public abstract partial class TypeDefinition {

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public new TypeReference reference {
            get {
                return (TypeReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 表示解析的标记位。
        /// </summary>
        public enum Flags {

            /// <summary>
            /// 标记当前成员是否包含内嵌类型。
            /// </summary>
            hasNestedTypes = 1 << 0,

            /// <summary>
            /// 标记已发生解析类型操作。
            /// </summary>
            resolveBaseTypesCalled = 1 << 1,

            /// <summary>
            /// 标记类型已全部解析。
            /// </summary>
            baseTypesResolved = 1 << 2,

            /// <summary>
            /// 标记已发生解析成员操作。
            /// </summary>
            resolveMemberCalled = 1 << 3,

            /// <summary>
            /// 标记成员已全部解析。
            /// </summary>
            memberResolved = 1 << 4,

            /// <summary>
            /// 标记关闭类型已调用。
            /// </summary>
            closeTypeBuilderCalled = 1 << 5,

        }

        /// <summary>
        /// 获取当前成员的标记位。
        /// </summary>
        public Flags flags;

        /// <summary>
        /// 判断或设置标记位。
        /// </summary>
        /// <param name="flag"></param>
        /// <returns></returns>
        protected bool checkFlag(Flags flag) {
            if ((flags & flag) != 0) {
                return true;
            }
            flags |= flag;
            return false;
        }

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        public sealed override void defineMember() {

            // 标记容器含子类型。
            var p = containerType;
            if (p != null) {
                p.flags |= Flags.hasNestedTypes;
            }

            // 创建引用。
            var member = reference = genericParameters == null ? new TypeReference(memberType) : new GenericTypeDefinitionReference(memberType, base.defineGenericParameters(genericParameters));
            member.modifiers = base.getModifiersWithDefaultAccessibility();
            member.name = name.value;
            base.addReferenceToContainer();

            // 检查修饰符。
            checkModifiers();

            base.defineMember();
        }

        /// <summary>
        /// 当被子类重写时，负责检查修饰符。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        protected virtual void checkModifiers() {

            var c = container.reference;
            switch (c.memberType) {

                case MemberType.@class:
                    if (modifiers.hasFlag(Modifiers.@protected)) {
                        if (c.modifiers.hasFlag(Modifiers.final)) {
                            base.reportMemberError(ErrorCode.none, "在最终类中定义了新的保护成员；应删除“protected”修饰符");
                        }
                        if (c.modifiers.hasFlag(Modifiers.@static)) {
                            base.reportMemberError(ErrorCode.none, "修饰符“protected”对静态类成员无效；应删除“protected”修饰符");
                        }
                    }
                    break;

                case MemberType.@namespace:
                    base.checkUnexpectedModifiers(Modifiers.@new, "全局成员");
                    break;

                case MemberType.@struct:
                    base.checkUnexpectedModifiers(Modifiers.@protected, "结构成员");
                    break;

                case MemberType.@interface:
                    base.reportMemberError(ErrorCode.none, "无法在接口内定义其它类型");
                    break;

                case MemberType.extension:
                    if (!modifiers.hasFlag(Modifiers.@private)) {
                        base.reportMemberError(ErrorCode.none, "无法在扩展内定义非私有类型");
                    }
                    break;

            }

        }

        /// <summary>
        /// 解析所有类型的基类型。
        /// </summary>
        public sealed override void resolveBaseTypes() {

            // 如果一个类 A 是另一个类 B 的基类，
            // 解析 B 时会自动解析解析 A，
            // 需要标记 A 以避免重复解析。
            if (checkFlag(Flags.resolveBaseTypesCalled)) {
                return;
            }

            // 解析继承列表。
            base.resolveBaseTypes(memberType, reference, baseTypes);
            checkBaseClass();

            // 标记基类已解析。
            flags |= Flags.baseTypesResolved;

            // 只处理子类型。所有泛型成员都可以生成基类型。
            if ((flags & Flags.hasNestedTypes) != 0) {
                base.resolveBaseTypes();
            }

        }

        /// <summary>
        /// 当被子类重写时，负责检查基类完整性。
        /// </summary>
        protected virtual void checkBaseClass() { }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public sealed override void resolveMember() {

            if (checkFlag(Flags.resolveMemberCalled)) {
                return;
            }

            // 确保基类已全部解析。
            if (baseTypes != null) {
                if (reference.baseClass != null && reference.baseClass.definition != null) {
                    reference.baseClass.definition.resolveMember();
                }
                if (reference.baseInterfaces != null) {
                    foreach (var t in reference.baseInterfaces) {
                        if (t.definition != null) {
                            t.definition.resolveMember();
                        }
                    }
                }
            }

            // 解析注解类型。
            base.resolveAnnotations();

            // 解析泛型参数。
            base.resolveGenericParameters(genericParameters);

            // 解析子成员。
            base.resolveMember();

            // 展开接口默认实现。
            checkBaseImplemention();

            // 标记成员已解析。所有泛型成员都可以生成子成员。
            flags |= Flags.memberResolved;

        }

        /// <summary>
        /// 当前类型下已显式声明的接口实现。
        /// </summary>
        private Dictionary<MemberReference, MemberReference> _explicitMembers;

        /// <summary>
        /// 当被子类重写时，负责检查接口实现。
        /// </summary>
        protected virtual void checkBaseImplemention() {

            // 无基类型不需要检查。
            if (baseTypes == null) {
                return;
            }

            var target = reference;
            var baseInterfaces = target.baseInterfaces;
            var baseTypeCount = baseInterfaces == null ? 0 : (baseTypes.Count - baseInterfaces.Count);

            // 确认当期类型已实现了接口所有的成员。
            if (baseInterfaces != null) {
                var i = baseTypeCount;
                foreach (var bi in baseInterfaces) {
                    var baseType = baseTypes[i++];

                    // 获取所有接口成员。
                    var ims = bi.getAllIneterfaceMembers();
                    if (ims == null) {
                        continue;
                    }

                    // 检查接口的所有成员在当前类是否都实现。
                    foreach (var im in ims) {

                        // 先从显式声明中查找。
                        var exist = target.getExplicitMember(im);
                        var foundFromExplicitMember = exist != null;

                        // 如果来自显式接口声明，则保存实现成员。
                        if (foundFromExplicitMember) {
                            if (_explicitMembers == null) {
                                _explicitMembers = new Dictionary<MemberReference, MemberReference>();
                            }
                            _explicitMembers[im] = exist;
                        }

                        //
                        // interface I<T> {
                        //
                        //    void fn(T a);
                        //    void fn(int a);
                        //    
                        // }
                        //
                        // I<int>.fn() 有两个。
                        //

                        // 然后从当前成员查找。
                        if (!foundFromExplicitMember) {
                            exist = target.getOverrideingMember(im);

                            // 未找到成员，直接报错。
                            if (exist == null) {
                                Compiler.error(ErrorCode.none, String.Format("“{0}”未实现接口成员“{1}”", target.signature, im.signature), baseType);
                                continue;
                            }

                            // 在当前成员找到非公开成员。
                            if (!exist.isPublic) {
                                Compiler.error(ErrorCode.none, String.Format("实现接口的成员不能是私有或保护的", reference.signature, im.signature), exist.definition.name);
                                continue;
                            }

                            // 如果接口和当前实现都提供了默认实现。
                            if (exist != im && im.modifiers.hasFlag(Modifiers.@virtual) && exist.modifiers.hasFlag(Modifiers.@virtual) && exist.container.memberType == MemberType.@interface) {
                                Compiler.error(ErrorCode.none, String.Format("无法确定“{0}”继承“{1}”还是“{2}”的默认实现；请为当前类型添加接口实现", target.signature, im.signature, exist.signature), baseType);
                                continue;
                            }

                        }

                        // 判断函数是否真正实现接口。
                        if (exist is MethodReference) {
                            var thisMember = (MethodReference)exist;
                            var baseMember = (MethodReference)im;

                            // 确保返回值一致。
                            if (thisMember.returnType != baseMember.returnType) {
                                if (foundFromExplicitMember) {
                                    Compiler.error(ErrorCode.none, String.Format("显式接口成员“{0}”应返回“{1}”", baseMember.name, baseMember.returnType.signature), exist.definition.name);
                                } else {
                                    Compiler.error(ErrorCode.none, String.Format("“{0}”未实现接口成员“{1}”；“{2}”应返回“{3}”", reference.signature, im.signature, thisMember.signature, baseMember.returnType.signature), baseType);
                                }

                                continue;
                            }

                            // 确保泛型参数一致。
                            int r = ResolveHelper.checkOverridingGenericTypeParameterConstraints(thisMember, baseMember);
                            if (r >= 0) {
                                if (foundFromExplicitMember) {
                                    Compiler.error(ErrorCode.none, String.Format("显式接口成员“{0}”的第 {1} 个泛型参数的约束和接口不完全一致", baseMember.signature, r), exist.definition.name);
                                } else {
                                    Compiler.error(ErrorCode.none, String.Format("“{0}”未实现接口成员“{1}”；“{2}”的第 {3} 个泛型参数的约束和接口不完全一致", reference.signature, im.signature, thisMember.signature, r + 1), baseType);
                                }
                            }
                            continue;
                        }

                        // 判断属性是否真正实现接口。
                        if (exist is PropertyReference) {
                            var thisMember = (PropertyReference)exist;
                            var baseMember = (PropertyReference)im;

                            // 确保返回值一致。
                            if (thisMember.returnType != baseMember.returnType) {
                                if (foundFromExplicitMember) {
                                    Compiler.error(ErrorCode.none, String.Format("显式接口成员“{0}”应返回“{1}”", baseMember.name, baseMember.returnType.signature), exist.definition.name);
                                } else {
                                    Compiler.error(ErrorCode.none, String.Format("“{0}”未实现接口成员“{1}”；“{2}”应返回“{3}”", reference.signature, im.signature, thisMember.signature, baseMember.returnType.signature), name);
                                }
                                continue;
                            }

                            if (baseMember.getAccessor != null) {
                                if (thisMember.getAccessor == null) {
                                    if (foundFromExplicitMember) {
                                        Compiler.error(ErrorCode.none, String.Format("显式接口成员“{0}”缺少 get 访问器", baseMember.signature), exist.definition.name);
                                    } else {
                                        Compiler.error(ErrorCode.none, String.Format("“{0}”未实现接口成员“{1}”；“{2}”缺少 get 访问器", reference.signature, im.signature, thisMember.signature), name);
                                    }
                                } else if (thisMember.getAccessor.modifiers.hasFlag(Modifiers.@private | Modifiers.@protected)) {
                                    if (foundFromExplicitMember) {
                                        Compiler.error(ErrorCode.none, String.Format("显式接口成员“{0}”的 get 访问器未公开", baseMember.signature), exist.definition.name);
                                    } else {
                                        Compiler.error(ErrorCode.none, String.Format("“{0}”未实现接口成员“{1}”；“{2}”的 get 访问器未公开", reference.signature, im.signature, thisMember.signature), name);
                                    }
                                }
                            }

                            if (baseMember.setAccessor != null) {
                                if (thisMember.setAccessor == null) {
                                    if (foundFromExplicitMember) {
                                        Compiler.error(ErrorCode.none, String.Format("显式接口成员“{0}”缺少 set 访问器", baseMember.signature), exist.definition.name);
                                    } else {
                                        Compiler.error(ErrorCode.none, String.Format("“{0}”未实现接口成员“{1}”；“{2}”缺少 set 访问器", reference.signature, im.signature, thisMember.signature), name);
                                    }
                                } else if (thisMember.setAccessor.modifiers.hasFlag(Modifiers.@private | Modifiers.@protected)) {
                                    if (foundFromExplicitMember) {
                                        Compiler.error(ErrorCode.none, String.Format("显式接口成员“{0}”的 set 访问器未公开", baseMember.signature), exist.definition.name);
                                    } else {
                                        Compiler.error(ErrorCode.none, String.Format("“{0}”未实现接口成员“{1}”；“{2}”的 set 访问器未公开", reference.signature, im.signature, thisMember.signature), name);
                                    }
                                }
                            }

                        }
                    }
                }
            }

            // 检查当前类是否已经实现了抽象类全部成员。
            if (baseTypeCount != 0 && target.baseClass != null && !target.isAbstract) {
                var absractMembers = target.baseClass.getAllAbstractMembers();
                if (absractMembers != null) {
                    foreach (var absractMember in absractMembers) {
                        // 在处理子成员时会判断成员是否真正重写，这里不额外检查。
                        if (target.getOverrideingMemberFromThis(absractMember.name, absractMember) == null) {
                            Compiler.error(ErrorCode.none, String.Format("“{0}”未实现抽象的成员“{1}”", target.signature, absractMember.signature), baseTypes[0]);
                        }
                    }
                }
            }

        }

        #region 将删

        /// <summary>
        ///   This function computes the Base class and also the
        ///   list of interfaces that the class or struct @c implements.
        ///   
        ///   The return value is an array (might be null) of
        ///   interfaces implemented (as Types).
        ///   
        ///   The @base_class argument is set to the base object or null
        ///   if this is `System.Object'. 
        /// </summary>
        protected virtual TypeReference[] ResolveBaseTypes(out FullNamedExpression base_class) {
            throw new Unreachable();
        }

        protected virtual bool DoDefineMembers() {
            Debug.Assert(!IsPartialPart);

            //if (iface_exprs != null) {
            //    foreach (var iface_type in iface_exprs) {
            //        if (iface_type == null)
            //            continue;

            //        // Ensure the base is always setup
            //        var compiled_iface = iface_type.MemberDefinition2 as InterfaceDefinition;
            //        if (compiled_iface != null)
            //            compiled_iface.Define();

            //        ObsoleteAttribute oa = iface_type.GetAttributeObsolete();
            //        if (oa != null && !IsObsolete)
            //            AttributeTester.Report_ObsoleteMessage(oa, iface_type.GetSignatureForError(), startLocation2, Compiler.Report);

            //        if (iface_type.genericParameterCount > 0) {
            //            // TODO: passing `this' is wrong, should be base type iface instead
            //            VarianceDecl.CheckTypeVariance(iface_type, Variance.Covariant, this);

            //            if (((GenericTypeReference)iface_type).HasDynamicArgument() && !IsCompilerGenerated) {
            //                Compiler.Report.Error(1966, startLocation2,
            //                    "`{0}': cannot implement a dynamic interface `{1}'",
            //                    GetSignatureForError(), iface_type.GetSignatureForError());
            //                return false;
            //            }
            //        }

            //        if (iface_type.IsGenericOrParentIsGeneric) {
            //            foreach (var prev_iface in iface_exprs) {
            //                if (prev_iface == iface_type || prev_iface == null)
            //                    break;

            //                if (!TypeSpecComparer.Unify.IsEqual(iface_type, prev_iface))
            //                    continue;

            //                Compiler.Report.Error(695, startLocation2,
            //                    "`{0}' cannot implement both `{1}' and `{2}' because they may unify for some type parameter substitutions",
            //                    GetSignatureForError(), prev_iface.GetSignatureForError(), iface_type.GetSignatureForError());
            //            }
            //        }
            //    }

            //    if (Kind == MemberKind.Interface) {
            //        foreach (var iface in reference.baseInterfaces) {
            //            MemberCache.AddInterface(iface);
            //        }
            //    }
            //}

            //if (base_type != null) {
            //    //
            //    // Run checks skipped during DefineType (e.g FullNamedExpression::ResolveAsType)
            //    //
            //    if (base_type_expr != null) {
            //        ObsoleteAttribute obsolete_attr = base_type.GetAttributeObsolete();
            //        if (obsolete_attr != null && !IsObsolete)
            //            AttributeTester.Report_ObsoleteMessage(obsolete_attr, base_type.GetSignatureForError(), base_type_expr.Location, Compiler.Report);

            //        if (IsGenericOrParentIsGeneric && base_type.IsAttribute) {
            //            Compiler.Report.Error(698, base_type_expr.Location,
            //                "A generic type cannot derive from `{0}' because it is an attribute class",
            //                base_type.GetSignatureForError());
            //        }
            //    }

            //    var baseContainer = base_type.MemberDefinition2 as ClassOrStructDefinition;
            //    if (baseContainer != null) {
            //        baseContainer.Define();

            //        //
            //        // It can trigger define of this type (for generic types only)
            //        //
            //        if (HasMembersDefined)
            //            return true;
            //    }
            //}

            //if (Kind == MemberKind.Struct || Kind == MemberKind.Class) {
            //    pending = PendingImplementation.GetPendingImplementations(this);
            //}

            //var count = members.Count;
            //for (int i = 0; i < count; ++i) {
            //    var mc = members[i] as InterfaceMemberDefinitionBase;
            //    if (mc == null || !mc.IsExplicitImpl)
            //        continue;

            //    try {
            //        mc.Define();
            //    } catch (Exception e) {
            //        throw new InternalErrorException(mc, e);
            //    }
            //}

            //for (int i = 0; i < count; ++i) {
            //    var mc = members[i] as InterfaceMemberDefinitionBase;
            //    if (mc != null && mc.IsExplicitImpl)
            //        continue;

            //    if (members[i] is MemberContainerDefinition)
            //        continue;

            //    try {
            //        members[i].Define();
            //    } catch (Exception e) {
            //        throw new InternalErrorException(members[i], e);
            //    }
            //}

            if (HasOperators) {
                CheckPairedOperators();
            }

            if (requires_delayed_unmanagedtype_check) {
                requires_delayed_unmanagedtype_check = false;
                foreach (var member in members2) {
                    var f = member as FieldDefinition;
                    if (f != null && f.MemberType2 != null && f.MemberType2.IsPointer)
                        TypeManager.VerifyUnmanaged(f.MemberType2, f.startLocation2);
                }
            }

            ComputeIndexerName();

            if (HasEquals && !HasGetHashCode) {
                Compiler.Report.Warning(659, 3, startLocation2,
                    "`{0}' overrides Object.Equals(object) but does not override Object.GetHashCode()", GetSignatureForError());
            }

            if (Kind == MemberKind.Interface && reference.baseInterfaces != null) {
                MemberCache.RemoveHiddenMembers(reference);
            }

            return true;
        }

        public bool AddField(FieldDefinition field) {
            //AddMember (field);

            if ((field.ModFlags & Modifiers.@static) != 0)
                return true;

            var first_field = PartialContainer.first_nonstatic_field;
            if (first_field == null) {
                PartialContainer.first_nonstatic_field = field;
                return true;
            }

            if (Kind == MemberKind.Struct && first_field.containerType != field.containerType) {
                Compiler.Report.SymbolRelatedToPreviousError(first_field.containerType);
                Compiler.Report.Warning(282, 3, field.startLocation2,
                    "struct instance field `{0}' found in different declaration from instance field `{1}'",
                    field.GetSignatureForError(), first_field.GetSignatureForError());
            }
            return true;
        }

        #endregion

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public sealed override void resolveBody() {

            // 检查注解。
            base.checkAnnotations();

            // 解析泛型参数。
            base.checkGenericParameters(genericParameters);

            // 解析成员列表。
            base.checkBaseTypes(memberType, reference, baseTypes);

            // 检查 new 关键字。
            base.checkNew();

            // 解析内部主体。
            base.resolveBody();

        }

        public virtual SourceUnit GetCompilationSourceFile() {
            return containerSourceUnit;
        }
    }

    /// <summary>
    /// 表示一个类定义。
    /// </summary>
    public partial class ClassDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.@class;
            }
        }

        /// <summary>
        /// 当被子类重写时，负责检查修饰符。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        protected sealed override void checkModifiers() {

            base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@new | Modifiers.final | Modifiers.@abstract | Modifiers.@static), "类");
            base.checkModifiers();

            if (modifiers.hasFlag(Modifiers.@abstract) && modifiers.hasFlag(Modifiers.final | Modifiers.@static)) {
                base.reportMemberError(ErrorCode.none, "抽象类不能同时是静态或最终的；应删除“abstract”修饰符");
            } else if (modifiers.hasFlag(Modifiers.@static) && modifiers.hasFlag(Modifiers.final)) {
                base.reportMemberError(ErrorCode.none, "静态类不能同时是抽象或最终的；应删除“final”修饰符");
            }

        }

        /// <summary>
        /// 当被子类重写时，负责检查基类完整性。
        /// </summary>
        protected sealed override void checkBaseClass() {

            var member = reference;

            // 静态类不允许继承。
            if (member.modifiers.hasFlag(Modifiers.@static)) {
                if (baseTypes != null) {
                    Compiler.error(ErrorCode.none, String.Format("“{0}”：静态类不允许继承", member.signature), baseTypes[0]);
                }
                return;
            }

            // Object 类不允许继承。
            if (member == PredefinedTypes.System_Object) {
                if (baseTypes != null) {
                    Compiler.error(ErrorCode.none, String.Format("基础库错误：基础库中类型“{0}”不允许继承", member.signature), baseTypes[0]);
                }
                member.baseClass = null;
                return;
            }

            // 如果未找到基类，则默认继承于 Object。
            if (member.baseClass == null) {
                member.baseClass = PredefinedTypes.System_Object;
                return;
            }

        }

        /// <summary>
        /// 当被子类重写时，负责检查特定的注解。
        /// </summary>
        protected sealed override void checkAnnotation(MemberAnnotation annotation) {
            if (annotation.resolvedTargetType == PredefinedTypes.System_AnnotationUsageAnnotation && !reference.name.EndsWith("Annotation")) {
                Compiler.error(ErrorCode.none, String.Format("注解“{0}”只适用于注解类；注解类名字必须以“Annotation”为后缀"), annotation.target);
            }
        }

    }

    /// <summary>
    /// 表示一个结构定义。
    /// </summary>
    public partial class StructDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.@struct;
            }
        }

        /// <summary>
        /// 当被子类重写时，负责检查修饰符。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        protected sealed override void checkModifiers() {
            base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@new), "结构");
            base.checkModifiers();
        }

        /// <summary>
        /// 当被子类重写时，负责检查基类完整性。
        /// </summary>
        protected sealed override void checkBaseClass() {
            Debug.Assert(reference.baseClass == null);
            // 结构默认继承于 ValueType。
            reference.baseClass = PredefinedTypes.System_ValueType;

        }

    }

    /// <summary>
    /// 表示一个接口定义。
    /// </summary>
    public partial class InterfaceDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.@interface;
            }
        }

        /// <summary>
        /// 当被子类重写时，负责检查修饰符。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        protected sealed override void checkModifiers() {
            base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@new), "接口");
            base.checkModifiers();
        }

        /// <summary>
        /// 当被子类重写时，负责检查基类完整性。
        /// </summary>
        protected sealed override void checkBaseClass() {
            // 接口不需要检查基类。
        }

        /// <summary>
        /// 当被子类重写时，负责展开接口信息。
        /// </summary>
        protected sealed override void checkBaseImplemention() {
            // 接口不需要检查接口实现。
        }

    }

    /// <summary>
    /// 表示一个枚举定义。
    /// </summary>
    public partial class EnumDefinition {

        /// <summary>
        /// 内部使用的用于存储值的字段。
        /// </summary>
        public static readonly string underlyingValueField = "value__";

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.@enum;
            }
        }

        /// <summary>
        /// 当被子类重写时，负责检查修饰符。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        protected sealed override void checkModifiers() {
            base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@new), "枚举");
            base.checkModifiers();
        }

        /// <summary>
        /// 当被子类重写时，负责检查基类完整性。
        /// </summary>
        protected sealed override void checkBaseClass() {
            TypeReference elementType = reference.baseClass;
            if (elementType == null) {
                elementType = PredefinedTypes.System_Int32;
            } else {
                ResolveHelper.checkConst(elementType, baseTypes[0]);
            }
            reference.baseClass = PredefinedTypes.System_Enum_T.makeGenericType(elementType);
        }

        /// <summary>
        /// 当被子类重写时，负责展开接口信息。
        /// </summary>
        protected sealed override void checkBaseImplemention() {
            // 枚举不需要检查接口实现。
        }

    }

    /// <summary>
    /// 表示一个扩展定义。
    /// </summary>
    public partial class ExtensionDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.extension;
            }
        }

        /// <summary>
        /// 获取当前成员对应的扩展引用。
        /// </summary>
        public new ExtensionReference reference {
            get {
                return (ExtensionReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        public override void defineMember() {

            var c = container.reference;
            // 静态扩展无法在此处处理。
            if (modifiers.hasFlag(Modifiers.@static)) {


                //var sourceUnit = parentSourceUnit;
                //if (sourceUnit.staticExtensions == null) {
                //    sourceUnit.staticExtensions = new List<ExtensionDefinition>();
                //}
                //sourceUnit.staticExtensions.Add(this);

                return;
            }

            reference = new ExtensionReference();
            c.addMember(reference);

            if (c.memberType != MemberType.@namespace) {
                base.reportMemberError(ErrorCode.none, "只能在全局范围定义扩展；无法将扩展内嵌在其它类型");
            }

            base.checkUnexpectedModifiers(~Modifiers.ACCESSIBILITY, "扩展");

        }

        /// <summary>
        /// 解析所有类型的基类型。
        /// </summary>
        public sealed override void resolveBaseTypes() {
            var target = targetType.resolveAsType(this, MemberUsage.@typeof);
            if (target == null) {
                return;
            }

            // 静态扩展：和普通成员一样处理。
            if (modifiers.hasFlag(Modifiers.@static)) {
                if (target.definition == null) {
                    Compiler.error(ErrorCode.none, String.Format("静态扩展只对当前项目内的类型有效；无法静态扩展导入类型“{0}”；应删除“static”修饰符", target.signature), targetType);
                    return;
                }

                if (target.genericArguments != null) {
                    Compiler.error(ErrorCode.none, String.Format("无法静态扩展泛型实体类“{0}”；应删除“static”修饰符，如需扩展泛型本身，应删除泛型实参", target.signature), targetType);
                    return;
                }

                // 确保目标类型已解析。
                target.definition.resolveBaseTypes();

                base.reference = target;
                base.defineMember();

                base.resolveBaseTypes(MemberType.extension, target, baseTypes);

                // 解析子类型的基类。
                base.resolveBaseTypes();

                // 将当前扩展的成员全部拷贝到源定义。
                var last = target.definition.members;
                while (last.next != null) {
                    last = last.next;
                }
                last.next = members;

                // 如果父级成员是结构且结构有多个静态扩展且每个扩展都定义了新的字段，则提示警告。

            } else {

                target.addExtension(reference);

            }


        }

        /// <summary>
        /// 应用静态扩展。
        /// </summary>
        public void applyExtension() {
            Debug.Assert(modifiers.hasFlag(Modifiers.@static), "只有静态扩展才能应用扩展");

        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public override void resolveMember() {
            //    var resolvedTargetType = targetType.resolveAsType(this, MemberUsage.@typeof);
            //    if (resolvedTargetType == null) {
            //        return;
            //    }

            //    // 确保目标类型已解析。
            //    TypeDefinition d = resolvedTargetType.memberDefinition as TypeDefinition;
            //    if (d != null && d.phase == TypeResolvePhase.unresolved) {
            //        d.resolveMember();
            //    }

            //    // 静态扩展：和普通成员一样处理。
            //    if (modifiers.hasFlag(Modifiers.@static)) {
            //        if (resolvedTargetType.memberDefinition == null) {
            //            Compiler.error(ErrorCode.none, String.Format("静态扩展只对当前项目内的类型有效；无法静态扩展导入类型“{0}”（应删除“static”修饰符）", resolvedTargetType.signature), this);
            //            return;
            //        }

            //        memberReference = resolvedTargetType;

            //        base.defineChildMembers(resolvedTargetType);

            //        ResolveHelper.resolveExtensionBaseTypes(this);

            //    } else {

            //        var member = new ExtensionReference();
            //        member.modifiers = modifiers;
            //        member.name = "@extension";
            //        member.targetType = resolvedTargetType;
            //        member.memberDefinition = this;

            //        // 在 defineMember() 中暂时保存 memberReference = container。
            //        ((MemberContainerReference)memberReference).addMember(member);
            //        resolvedTargetType.addExtension(member);
            //        memberReference = member;

            //        base.defineChildMembers(member);

            //        if (baseTypes != null) {
            //            Compiler.error(ErrorCode.none, "无法扩展继承列表", baseTypes[0]);
            //        }
            //    }

            //    base.resolveChildTypes();
        }

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public override void resolveBody() {
            base.resolveBody();
        }

    }

    #endregion

    #region NamespaceDefinitions

    /// <summary>
    /// 表示一个命名空间定义。
    /// </summary>
    public partial class NamespaceDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.@namespace;
            }
        }

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        public sealed override void defineMember() {

            var c = container.reference;
            if (names != null) {
                foreach (var item in names) {
                    c = defineNamespace(c, item);
                }
                name = names[0];
            } else {
                c = defineNamespace(c, name);
            }

            reference = c;

            if (c.memberType != MemberType.@namespace) {
                base.reportMemberError(ErrorCode.none, "只能在全局范围定义命名空间");
            }

            base.defineMember();
        }

        private static NamespaceReference defineNamespace(NamespaceReference container, Identifier name) {
            var exist = container.getMember(name.value);
            if (exist != null) {
                if (exist.memberType != MemberType.@namespace) {
                    Compiler.error(ErrorCode.none, String.Format("“{0}”已存在名为“{1}”的{2}定义；如需扩展该{2}，请使用“extend”关键字", container.signature, exist.name, exist.memberType.getReadableName()), name);
                    return container;
                }

                return (NamespaceReference)exist;
            }

            var member = new NamespaceReference();
            member.name = name.value;
            container.addMember(member);
            return member;
        }

    }

    /// <summary>
    /// 表示一个源编译单元。
    /// </summary>
    public partial class SourceUnit {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.@namespace;
            }
        }

        ///// <summary>
        ///// 存储当前模块下的所有静态扩展。
        ///// </summary>
        //public List<ExtensionDefinition> staticExtensions;

        /// <summary>
        /// 获取当前容器下所有的导入的命名空间列表。检索名字时将会在此列表中指定的容器中查找是否存在匹配项。
        /// </summary>
        List<NamespaceReference> _importNamespaces;

        /// <summary>
        /// 当前容器下所有的导入别名列表。检索名字时将会使用此别名代替实际使用的成员名。
        /// </summary>
        Dictionary<string, MemberReference> _importAliases;

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        public sealed override void defineMember() {
            reference = container.reference;
            base.defineMember();
        }

        /// <summary>
        /// 解析所有类型的基类型。
        /// </summary>
        public sealed override void resolveBaseTypes() {

            // 解析导入列表。
            resolveImports();

            base.resolveBaseTypes();

            //if (staticExtensions != null) {
            //    foreach (var staticExtension in staticExtensions) {
            //        staticExtension.resolveTypes();
            //    }
            //}

        }

        /// <summary>
        /// 解析当前源内的导入项。
        /// </summary>
        public void resolveImports() {

            // 解析导入项时，可能同时解析其它类，
            // 而其它类所在的文件的导入项可能未解析。
            // import a = B;
            // class B : A { }

            if (_importNamespaces != null) {
                return;
            }

            _importNamespaces = new List<NamespaceReference>();

            // 首先定义所有别名。
            for (var directive = importDirectives; directive != null; directive = directive.next) {
                if (directive.alias != null) {
                    if (_importAliases == null) {
                        _importAliases = new Dictionary<string, MemberReference>();
                    }
                    string aliasName = directive.alias.value;

                    if (_importAliases.ContainsKey(aliasName)) {
                        Compiler.error(ErrorCode.none, String.Format("当前上下文已存在别名“{0}”", aliasName), directive.alias);
                        continue;
                    }

                    if (reference.getMember(aliasName, 0) != null) {
                        Compiler.error(ErrorCode.none, String.Format("无法使用“{0}”作为别名；当前上下文已存在同名的定义", aliasName), directive.alias);
                        continue;
                    }

                    _importAliases.Add(aliasName, null);
                }
            }

            // 解析所有导入项。
            for (var directive = importDirectives; directive != null; directive = directive.next) {
                if (directive.alias == null) {
                    var target = directive.value.resolveAsMember(container, MemberUsage.importTarget);
                    if (target == null) {
                        continue;
                    }

                    switch (target.memberType) {
                        case MemberType.@namespace:
                        case MemberType.@enum:
                            break;
                        case MemberType.@class:
                            if (!target.modifiers.hasFlag(Modifiers.@static)) {
                                Compiler.error(ErrorCode.none, String.Format("“import”指令只能只导入命名空间、枚举和静态类；无法导入非静态类“{0}”", target.signature), this);
                                continue;
                            }
                            break;
                        case MemberType.specailType:
                            Compiler.error(ErrorCode.none, String.Format("“import”指令只能只导入命名空间、枚举和静态类；无法导入“{0}”", target.signature), this);
                            continue;
                        default:
                            Compiler.error(ErrorCode.none, String.Format("“import”指令只能只导入命名空间、枚举和静态类；无法导入{0}“{1}”", target.memberType.getReadableName(), target.signature), this);
                            continue;
                    }

                    if (_importNamespaces.Contains((NamespaceReference)target)) {
                        Compiler.warning(ErrorCode.none, String.Format("当前上下文已声明导入“{0}”", target.signature), directive.value);
                        continue;
                    }

                    _importNamespaces.Add((NamespaceReference)target);

                }
            }

            // 解析所有 imports alias 项
            if (_importAliases != null) {
                for (var directive = importDirectives; directive != null; directive = directive.next) {
                    if (directive.alias != null) {
                        var target = directive.value.resolveAsMember(container, MemberUsage.importAlias);
                        if (target == null) {
                            continue;
                        }

                        //if (!(target is TypeReference)) {
                        //    Compiler.error(ErrorCode.none, String.Format("只能为类型定义别名；无法定义{0}“{1}”的别名", target.memberType.getReadableName(), target.signature), directive.value);
                        //    continue;
                        //}

                        //if (target.memberType == MemberType.specailType) {
                        //    Compiler.error(ErrorCode.none, String.Format("无法定义“{0}”的别名", target.signature), this);
                        //    continue;
                        //}

                        _importAliases[directive.alias.value] = target;

                    }
                }
            }

        }

    }

    /// <summary>
    /// 表示一个模块定义。
    /// </summary>
    public partial class ModuleDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.@namespace;
            }
        }

        /// <summary>
        /// 获取当前成员对应的包引用。
        /// </summary>
        public new ModuleReference reference {
            get {
                return (ModuleReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 对当前模块定义进行语义分析。
        /// </summary>
        public void resolve() {

            // 定义所有成员。
            defineMember();
            if (Compiler.errorCount > 0) {
                return;
            }

            // 导入系统成员。
            if (Compiler.options.isCompilingCoreLib) {
                //    PredefinedTypes.importFrom(this);
            }
            AssemblyImporter.import(reference);

            // 解析基类型。
            resolveBaseTypes();
            if (Compiler.errorCount > 0) {
                return;
            }

            // 解析成员。
            resolveMember();
            if (Compiler.errorCount > 0) {
                return;
            }

            // 解析成员主体。
            resolveBody();

            //    // 处理否定成员。
            //    if (_deferedDeprecatedMembers != null) {
            //        foreach (var vk in _deferedDeprecatedMembers) {
            //            ResolveHelper.checkDeprecated((MemberReference)vk.Key, vk.Value);
            //        }
            //        _deferedDeprecatedMembers = null;
            //    }

        }

        ///// <summary>
        ///// 由于否定属性未解析，延迟提示的否定成员列表。
        ///// </summary>
        //List<KeyValuePair<TypeReference, Node>> _deferedDeprecatedMembers;

        //public void addDeferedDeprecatedMembers(TypeReference type, Node srcNode) {
        //    if (_deferedDeprecatedMembers == null) {
        //        _deferedDeprecatedMembers = new List<KeyValuePair<TypeReference, Node>>(16);
        //    }
        //    _deferedDeprecatedMembers.Add(new KeyValuePair<TypeReference, Node>(type, srcNode));
        //}

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        public sealed override void defineMember() {
            reference = new ModuleReference();
            base.defineMember();
        }

    }

    #endregion

    #region TypeMemberDefinitions

    /// <summary>
    /// 表示一个类型子成员定义。
    /// </summary>
    public abstract partial class TypeMemberDefinition {

        #region 语义解析

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public new TypeMemberReference reference {
            get {
                return (TypeMemberReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 解析所有类型的基类型。
        /// </summary>
        public sealed override void resolveBaseTypes() {
            // 普通成员不检查基类。
        }

        #endregion

        #region 修饰符

        /// <summary>
        /// 检查指定类型成员的修饰符是否合法。
        /// </summary>
        protected void checkModifiers() {

            NamespaceReference c = container.reference;
            switch (c.memberType) {

                case MemberType.@class:

                    // 检查 protected & virtual
                    if (c.modifiers.hasFlag(Modifiers.final)) {
                        if (modifiers.hasFlag(Modifiers.@protected) && !modifiers.hasFlag(Modifiers.@override)) {
                            Compiler.warning(ErrorCode.none, String.Format("“{0}”：在最终类中定义了新的保护成员；应删除“protected”修饰符", reference.signature), name);
                        }
                        if (modifiers.hasFlag(Modifiers.@virtual)) {
                            Compiler.warning(ErrorCode.none, String.Format("“{0}”：在最终类中定义了新的虚成员；应删除“virtual”修饰符", reference.signature), name);
                        }
                    }

                    // 检查 static
                    if (c.modifiers.hasFlag(Modifiers.@static)) {
                        if (!modifiers.hasFlag(Modifiers.@static | Modifiers.@const)) {
                            base.reportMemberError(ErrorCode.none, "静态类只能包含静态或常量成员；应添加“static”修饰符");
                        }
                        if (modifiers.hasFlag(Modifiers.@protected)) {
                            base.reportMemberError(ErrorCode.none, "修饰符“protected”对静态类成员无效；应删除“protected”修饰符");
                        }
                    }

                    // 检查 abstract
                    if (modifiers.hasFlag(Modifiers.@abstract) && !c.modifiers.hasFlag(Modifiers.@abstract)) {
                        base.reportMemberError(ErrorCode.none, "只能在抽象类定义抽象成员；应在所属类型添加“abstract”修饰符");
                    }
                    break;

                case MemberType.@struct:
                    base.checkUnexpectedModifiers(Modifiers.@virtual | Modifiers.@abstract | Modifiers.@override | Modifiers.@protected, "结构成员");
                    break;

                case MemberType.@interface:
                    base.checkUnexpectedModifiers(~Modifiers.@new, "接口成员");
                    break;

                case MemberType.extension:
                    base.checkUnexpectedModifiers(Modifiers.@new | Modifiers.@abstract | Modifiers.@virtual | Modifiers.@override | Modifiers.final | Modifiers.@protected, "扩展成员");
                    break;

                case MemberType.@namespace:

                    // 全局默认静态的。
                    reference.modifiers |= Modifiers.@static;

                    base.checkUnexpectedModifiers(Modifiers.@new | Modifiers.@virtual | Modifiers.@abstract | Modifiers.@override, "全局成员");
                    break;
            }

        }

        /// <summary>
        /// 检查 params 相关修饰符是否合法。
        /// </summary>
        protected void checkParams() {
            if (modifiers.hasFlag(Modifiers.@params) && modifiers.hasFlag(Modifiers.@static | Modifiers.@const)) {
                base.reportMemberError(ErrorCode.none, "静态字段或属性不能标记为“params”；应删除“params”修饰符");
            }
        }

        /// <summary>
        /// 检查方法主体是否符合 absract/extern 要求。
        /// </summary>
        /// <param name="body">当前成员的主体。</param>
        protected void checkAbstractAndExtern(ToplevelBlock body) {

            bool hasBody = body != null;

            // 接口成员自动根据其实体判断是否为抽象成员还是虚成员。
            if (reference.container.memberType == MemberType.@interface) {
                reference.modifiers |= hasBody ? Modifiers.@virtual : Modifiers.@abstract;
                return;
            }

            if (modifiers.hasFlag(Modifiers.@abstract | Modifiers.@extern) == hasBody) {
                if (hasBody) {
                    base.reportMemberError(ErrorCode.unepectedAbstractOrExtern, String.Format("“{0}”：有实体的方法不能标记为“abstract”或“extern”；应删除“abstract”和“extern”修饰符", reference.signature));
                } else {
                    base.reportMemberError(ErrorCode.epectedAbstractOrExtern, String.Format("“{0}”：缺少实体的方法必须标记为“abstract”或“extern”；应添加“abstract”或“extern”修饰符", reference.signature));
                }
            }
        }

        /// <summary>
        /// 检查 extern 修饰符是否合法。
        /// </summary>
        protected void checkExtern() {
            //// for extern static method must be specified either DllImport attribute or MethodImplAttribute.
            //// We are more strict than csc and report this as an error because SRE does not allow emit that
            //if ((ModFlags & Modifiers.@extern) != 0 && !is_external_implementation && (attributes == null || !attributes.HasResolveError())) {
            //    if (this is ConstructorDefinition) {
            //        Compiler.Report.Warning(824, 1, startLocation2,
            //            "Constructor `{0}' is marked `external' but has no external implementation specified", GetSignatureForError());
            //    } else {
            //        Compiler.Report.Warning(626, 1, startLocation2,
            //            "`{0}' is marked as an external but has no DllImport attribute. Consider adding a DllImport attribute to specify the external implementation",
            //            GetSignatureForError());
            //    }
            //}

        }

        #endregion

        #region 参数返回值

        /// <summary>
        /// 定义参数列表。
        /// </summary>
        /// <param name="parameters">参数定义。</param>
        /// <returns></returns>
        protected MethodReference.Parameter[] defineParameters(Parameter parameters) {

            // 计算参数数。
            var paramCount = 0;
            for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next) {
                paramCount++;
            }

            var result = new Teal.Compiler.MethodReference.Parameter[paramCount];

            var foundOptional = false;
            var foundParams = false;

            var i = 0;
            for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next, i++) {

                var p = result[i] = new Teal.Compiler.MethodReference.Parameter();
                p.variableType = parameter.variableType;
                var n = p.name = parameter.name.value;

                // 检查参数修饰符。
                if (foundParams) {
                    Compiler.error(ErrorCode.none, "含有“params”修饰符的参数后面不能有其它参数", parameter.name);
                }

                switch (parameter.variableType) {
                    case VariableType.paramsParameter:
                    case VariableType.argListParameter:
                        foundParams = true;
                        break;
                    default:
                        if (parameter.initialiser != null) {
                            foundOptional = true;
                        } else if (foundOptional) {
                            Compiler.error(ErrorCode.none, "非可选参数必须出现在其它可选参数的前面", parameter);
                        }
                        break;
                }

                // 检查参数名。

                // 参数名不能重复。
                for (int j = 0; j < i; j++) {
                    if (result[j].name == n) {
                        Compiler.error(ErrorCode.none, String.Format("当前{0}已经包含名为“{1}”的参数", memberType.getReadableName(), n), parameter.name);
                        break;
                    }
                }

                // 参数名不能和泛型参数同名。
                if (reference.getGenericParameter(n) != null) {
                    Compiler.error(ErrorCode.none, String.Format("当前{0}已经包含名为“{1}”的泛型参数", memberType.getReadableName(), n), parameter.name);
                }

                // 标记参数已定义。
                parameter.declareState = State.on;
                if (parameter.variableType != VariableType.outParameter) {
                    parameter.isEverAssigned = true;
                }

            }

            return result;
        }

        /// <summary>
        /// 解析函数参数类型。
        /// </summary>
        /// 
        /// <param name="parameters">函数的参数。</param>
        protected void resolveParameters(Parameter parameters) {
            if (parameters == null) {
                return;
            }
            var ps = reference.parameters;
            var i = 0;
            for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next, i++) {

                // 处理 ... 和 func
                if (parameter.type == null) {
                    ps[i].type = PredefinedTypes.System_Object;
                    continue;
                }

                // 解析参数类型。
                var resolved = ps[i].type = parameter.type.resolveAsType(this, MemberUsage.variableType);
                if (resolved == null) {
                    continue;
                }
                if (resolved == PredefinedTypes.var) {
                    ResolveHelper.reportVarAsDynamicError(parameter.type);
                    resolved = PredefinedTypes.System_Object;
                } else {
                    if (!resolved.isAccessibleAs(reference)) {
                        Compiler.error(ErrorCode.none, String.Format("“{0}”：参数类型“{1}”的访问权限不能低于“{2}”本身", reference.signature, resolved.signature, memberType.getReadableName()), parameter.type);
                    }
                    ResolveHelper.checkVaribaleType(resolved, parameter.type);
                }

                // params 参数的类型必须是可迭代对象。
                if (parameter.variableType == VariableType.paramsParameter && resolved.genericDefinition != PredefinedTypes.System_Collections_IEnumeratable_T) {
                    Compiler.error(ErrorCode.none, String.Format("“{0}”：“params”参数类型必须是可迭代对象", reference.signature, resolved.signature, memberType.getReadableName()), parameter.type);
                }
            }
        }

        /// <summary>
        /// 检查方法参数的合法性。
        /// </summary>
        /// <param name="parameters"></param>
        protected void checkParameters(Parameter parameters) {
            if (parameters == null) {
                return;
            }
            var ps = reference.parameters;
            int i = 0;
            for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next, i++) {

                // 检查参数类型。
                ps[i].type.checkType(parameter.type);

                // 解析参数默认值。
                if (parameter.initialiser != null) {
                    //parameter.initialiser = parameter.initialiser.resolveAsValue(ResolveHelper.createResolveContext(this), parameter.resolvedType);
                }
            }
        }

        /// <summary>
        /// 解析返回值类型。
        /// </summary>
        /// <param name="memberDefinition">要处理的成员定义。</param>
        /// <param name="returnType">要解析的方法返回值的源节点。</param>
        /// <param name="allowVoid">如果为 <c>true</c>，表示允许为 void。</param>
        /// <returns></returns>
        protected TypeReference resolveReturnType(Expression returnType, bool allowVoid) {

            // 处理构造函数和 func
            if (returnType == null) {
                return PredefinedTypes.@void;
            }

            // 解析返回类型。
            var resolved = returnType.resolveAsType(this, MemberUsage.returnType);
            if (resolved == null) {
                return null;
            }

            if (resolved.memberType == MemberType.specailType) {
                if (resolved == PredefinedTypes.@void) {
                    if (!allowVoid) {
                        ResolveHelper.checkVaribaleType(resolved, returnType);
                    }
                } else {
                    ResolveHelper.reportVarAsDynamicError(returnType);
                    resolved = PredefinedTypes.System_Object;
                }
            } else {
                if (!resolved.isAccessibleAs(reference)) {
                    Compiler.error(ErrorCode.none, String.Format("“{0}”：返回类型“{1}”的访问权限不能低于成员本身", reference.signature, resolved.signature), returnType);
                }

                ResolveHelper.checkVaribaleType(resolved, returnType);
            }

            return resolved;

        }

        /// <summary>
        /// 检查方法或索引器重载是否合法。
        /// </summary>
        protected void checkOverload() {
            var m = reference;
            for (var c = m.container.getMember(m.name); c != m; c = c.next) {
                if (isOverriding((TypeMemberReference)c, m)) {
                    Compiler.error(ErrorCode.none, String.Format("“{0}”下已存在名为“{1}”且具有相同参数类型的“{2}”定义", m.container.signature, name.value, m.memberType.getReadableName()), name);
                    return;
                }
            }
        }

        /// <summary>
        /// 判断当前参数和指定参数是否具有相同的属性。
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        private static bool isOverriding(TypeMemberReference x, TypeMemberReference y) {

            var px = x.parameters;
            var py = y.parameters;

            Debug.Assert(px != null);
            Debug.Assert(py != null);

            if (px.Length != py.Length) {
                return false;
            }

            if (!x.hasSameGenericParameterCount(y)) {
                return false;
            }

            for (int i = 0; i < px.Length; i++) {
                if (!ResolveHelper.isOverriding(px[i].type, py[i].type)) {
                    return false;
                }
            }

            return true;
        }

        #endregion

        #region 主体

        ///// <summary>
        ///// 创建一个用于语句和表达式解析的上下文对象。
        ///// </summary>
        ///// <param name="memberDefinition">要处理的成员定义。</param>
        ///// <returns></returns>
        //public static ResolveContext createResolveContext(MemberDefinition this) {
        //    var result = new ResolveContext();
        //    result.currentMemberDefinition = memberDefinition;
        //    return result;
        //}

        /// <summary>
        /// 解析方法的主体。
        /// </summary>
        /// <param name="memberDefinition">要处理的成员定义。</param>
        /// <param name="body">要解析的主体。</param>
        /// <param name="returnType">主体的返回类型。</param>
        /// <param name="parameters">主体的参数。</param>
        protected void resolveMethodBody(ToplevelBlock body, TypeReference returnType, Parameter parameters) {

            if (body == null) {
                checkExtern();
                return;
            }

            // body.resolve(ResolveHelper.createResolveContext(this), returnType, parameters, null);

        }

        #endregion

    }

    /// <summary>
    /// 表示一个字段定义。
    /// </summary>
    public partial class FieldDefinition {

        #region 暂时不能删除


        public FieldDefinition() { }

        public Expression Initializer {
            get;
            set;
        }

        public string Name {
            get {
                return variables.name.value;
            }
        }

        public FieldReference Spec {
            get {
                return reference;
            }
        }

        public virtual Constant ConvertInitializer(ResolveContext rc, Constant expr) {
            if (containerType is EnumDefinition) {
                if (expr is EnumConstant)
                    expr = ((EnumConstant)expr).Child;

                var underlying = ((EnumDefinition)containerType).UnderlyingType;
                if (expr != null) {
                    expr = expr.ImplicitConversionRequired(rc, underlying);
                    if (expr != null && !IsValidEnumType(expr.Type)) {
                        EnumDefinition.Error_1008(startLocation2, Compiler.Report);
                        expr = null;
                    }
                }

                if (expr == null)
                    expr = NewExpression.Constantify(underlying, startLocation2);

                return new EnumConstant(expr, MemberType2);
            }
            return expr.ConvertImplicitly(MemberType2);
        }

        static bool IsValidEnumType(TypeReference t) {
            switch (t.BuiltinType) {
                case BuiltinTypeSpec.Type.Int:
                case BuiltinTypeSpec.Type.UInt:
                case BuiltinTypeSpec.Type.Long:
                case BuiltinTypeSpec.Type.Byte:
                case BuiltinTypeSpec.Type.SByte:
                case BuiltinTypeSpec.Type.Short:
                case BuiltinTypeSpec.Type.UShort:
                case BuiltinTypeSpec.Type.ULong:
                case BuiltinTypeSpec.Type.Char:
                    return true;
                default:
                    return t.IsEnum;
            }
        }


        #endregion

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public new FieldReference reference {
            get {
                return (FieldReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.field;
            }
        }

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public FieldReference[] references;

        /// <summary>
        /// 创建当前成员对应的引用。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        public override void defineMember() {

            // 计算变量个数。
            int variableCount = 0;
            for (var variable = variables; variable != null; variable = variable.next) {
                variableCount++;
            }

            // 解析每个字段。
            references = new FieldReference[variableCount];
            int i = 0;
            for (var variable = variables; variable != null; variable = variable.next, i++) {

                // 更新当前对象对应的字段，主要为 base.reportMemberError 能获取到当前的成员。
                name = variable.name;

                var member = reference = references[i] = new FieldReference();
                member.modifiers = base.getModifiersWithDefaultAccessibility();
                member.name = name.value;
                base.addReferenceToContainer();

                if (i == 0) {
                    switch (container.reference.memberType) {
                        case MemberType.@interface:
                            base.reportMemberError(ErrorCode.fieldInInterface, "接口不能包含字段");
                            break;

                        case MemberType.extension:
                            base.reportMemberError(ErrorCode.fieldInExtension, "无法扩展字段");
                            break;
                    }
                    base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@new | Modifiers.@static | Modifiers.final | Modifiers.@const | Modifiers.@volatile | Modifiers.@params), "字段");
                    base.checkModifiers();
                    base.checkParams();
                    if (modifiers.hasFlag(Modifiers.@const) && modifiers.hasFlag(Modifiers.@static | Modifiers.final | Modifiers.@volatile)) {
                        base.reportMemberError(ErrorCode.none, "已标记为“const”的字段不能同时标记为“static”、“final”或“volatile”；应删除“const”修饰符");
                    }
                    if (modifiers.hasFlag(Modifiers.@volatile) && modifiers.hasFlag(Modifiers.final)) {
                        base.reportMemberError(ErrorCode.none, "已标记为“volatile”的字段不能同时标记为“final”；应删除“@volatile”修饰符");
                    }
                }

            }

        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public override void resolveMember() {

            // 解析注解。
            base.resolveAnnotations();

            // 解析返回类型。
            var returnType = base.resolveReturnType(variables.type, false);

            var i = 0;
            for (var variable = variables; variable != null; variable = variable.next, i++) {

                // 更新当前对象对应的字段，主要为 base.reportMemberError 能获取到当前的成员。
                name = variable.name;
                reference = references[i];

                reference.returnType = returnType;

                // 验证返回类型。
                if (i == 0 && returnType != null) {
                    if (modifiers.hasFlag(Modifiers.@const)) {
                        ResolveHelper.checkConst(returnType, variables.type);
                    } else if (modifiers.hasFlag(Modifiers.@volatile)) {
                        ResolveHelper.checkVolatile(returnType, variables.type);
                    }
                }

                base.checkNew();

                if (Initializer != null) {
                    //if (reference.parentContainer.memberType == MemberType.@struct && !reference.modifiers.hasFlag(Modifiers.@static)) {
                    //    Compiler.error(ErrorCode.none, String.Format("“{0}”：结构中的实例字段不能有初始值", reference.signature), initializer);
                    //}

                    // Parent.RegisterFieldForInitialization(this, initializer);
                }

            }

        }

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public override void resolveBody() {

            // 解析每个字段。
            var isConst = modifiers.hasFlag(Modifiers.@const);
            var i = 0;
            for (var variable = variables; variable != null; variable = variable.next, i++) {

                // 更新当前对象对应的字段，主要为 ResolveHelper.checkXXX 能获取到当前的成员。
                var member = reference = references[i];
                name = variable.name;

                if (i == 0) {

                    // 检查注解。
                    base.checkAnnotations();

                    // 检查返回类型。
                    member.returnType.checkType(variable.type);

                }

                // 解析字段初始值。
                resolveField(member, variable);

                // 确认常量字段的值为常量。
                if (isConst && !(member.initialValue is Constant)) {
                    if (variable.initialiser == null) {
                        Compiler.error(ErrorCode.expectedConstInitialValue, "常量字段必须有常量初始值", variable.name);
                    } else if (member.initialValue != null) {
                        Compiler.error(ErrorCode.expectedConstInitialValue, "常量字段必须有常量初始值", variable.initialiser);
                    }
                }

            }

            // 结构非静态字段需要检查结构循环。
            if (!reference.modifiers.hasFlag(Modifiers.@static) && reference.container.memberType == MemberType.@struct) {
                checkCircleValueType(references[0].returnType);
            }
        }

        /// <summary>
        /// 当被子类重写时，负责检查特定的注解。
        /// </summary>
        protected override void checkAnnotation(MemberAnnotation annotation) {

            // @fixedBuffer
            if (annotation.resolvedTargetType == PredefinedTypes.System_RunTime_FixedBufferAnnotation) {

                //if (member.returnType.underlyingReference != PredefinedTypes.System_Ptr_T) {
                //    Compiler.error(ErrorCode.none, String.Format("只有指针类型的字段才能使用“{0}”注解", member.returnType.signature), variable.type);
                //}
                //if (member.parentContainer.memberType != MemberType.@struct) {
                //    base.reportMemberError(ErrorCode.none, String.Format("只有结构成员才能使用“{0}”注解", member.returnType.signature));
                //}
                //// todo
                ////IntConstant constant = fixedBuffer.resolvedTarget.arguments != null && fixedBuffer.resolvedTarget.arguments.Length > 0 &&fixedBuffer.resolvedTarget.arguments[0] as IntConstant;
                ////if (constant != null && (constant.Value < 0 || constant >= int.MaxValue / member.returnType.size) {
                ////   Compiler.error(ErrorCode.none, String.Format("固定缓存的大小必须在 0 到 ", member.returnType.signature), fixedBuffer.arguments);
                ////}


                if (modifiers.hasFlag(Modifiers.@static |
                    Modifiers.@const)) {
                    Compiler.error(ErrorCode.none, String.Format("注解“{0}”对常量或静态成员无效", PredefinedTypes.System_RunTime_FixedBufferAnnotation.signature), annotation.target);
                }

                var layout = container.getAnnotation(PredefinedTypes.System_RunTime_StructLayoutAnnotation);
                if (layout == null /* || layout 不是 Explicit */) {
                    Compiler.error(ErrorCode.none, String.Format("注解“{0}”只能对已标为 LayoutKind.Explicit 的结构成员有效", PredefinedTypes.System_RunTime_FixedBufferAnnotation.signature), annotation.target);
                    return;
                }

            }

            // @fieldOffset
            if (annotation.resolvedTargetType == PredefinedTypes.System_RunTime_FieldOffsetAnnotation) {

                //// 确保字段有偏移数。
                //if (parentContainer.hasExplictLayout && !modifiers.hasFlag(Modifiers.@static | Modifiers.BACKING_FIELD) && getAnnotation(PredefinedTypes.System_RunTime_FieldOffsetAnnotation) == null) {
                //    base.reportMemberError(ErrorCode.none, "已标记为 LayoutKind.Explicit 的结构字段必须标记 FieldOffset");
                //}

                //base.reportMemberError(ErrorCode.none, "已标记为 LayoutKind.Explicit 的结构字段必须标记 FieldOffset");
            }

            //// @permission
            //if (annotation.resolvedTargetType == PredefinedTypes.System_RunTime_PermissionAnnotation) {
            //    Compiler.error(ErrorCode.none, String.Format("注解“{0}”对字段无效", PredefinedTypes.System_RunTime_PermissionAnnotation.signature), annotation.target);
            //}
            base.checkAnnotation(annotation);
        }

        /// <summary>
        /// 解析当前字段定义的指定字段。
        /// </summary>
        /// <param name="field">要解析的字段。</param>
        /// <param name="variable">要解析的变量。</param>
        /// <returns>如果当前字段正在解析，则返回 true。否则返回 false。</returns>
        public bool resolveField(FieldReference field, Variable variable) {

            // 获取定义指定字段的变量。
            // 如果字段无源定义，则代表已解析。
            // 如果正在解析时发现重复解析，则需要报错。
            if (variable != null) {
                switch (variable.declareState) {
                    case State.unset:

                        // 解析字段初始值。
                        if (variable.initialiser != null) {
                            variable.declareState = State.off;
                            var oldReference = reference;
                            reference = field;
                            //  field.initialValue = variable.initialiser.resolveAsValue(ResolveHelper.createResolveContext(this), field.returnType);
                            reference = oldReference;
                        }

                        variable.declareState = State.on;
                        break;
                    case State.off:

                        // 避免多次报错。
                        variable.declareState = State.on;
                        return false;
                }
            }

            return true;
        }

        /// <summary>
        /// 检查当前字段的类型是否导致所在类型的大小无法确定。
        /// </summary>
        /// <param name="other">要检查的字段。</param>
        private bool checkCircleValueType(TypeReference other) {

            // 只处理泛型定义本身。
            other = other.genericDefinitionType;

            // 不处理内置类型、导入类型、非结构类型。
            if (other.primitiveType != PrimitiveType.none || other.definition == null || other.memberType != MemberType.@struct) {
                return true;
            }

            // 如果经过迭代发现目标类型和当前所在类型相同，表示冲突。
            if (other == reference.containerType) {
                Compiler.error(ErrorCode.none, String.Format("检测到字段“{0}”导致“{1}”和“{2}”有循环内嵌关系", references[0].signature, reference.containerType.signature, references[0].returnType), variables.type);
                references[0].returnType = null;
                return false;
            }

            // 检测目标类型所有字段，是否和当前类型存在冲突。
            for (var member = other.definition.members; member != null; member = member.next) {
                if (member.reference.memberType != MemberType.field || member.modifiers.hasFlag(Modifiers.@static)) {
                    continue;
                }
                var field = (FieldDefinition)member;
                var type = field.references[0].returnType;

                // 如果之前检查过错误，则 type 可能为 null。
                if (type == null) {
                    continue;
                }

                // 继续检查其实现。
                if (!checkCircleValueType(type)) {
                    return false;
                }

                // 不允许泛型参数为结构自身。 
                //
                // struct A {
                //    B<A> a;
                // }
                // 
                // struct B<T> {
                //    T a;
                // }
                //
                if (type.genericArguments != null) {
                    foreach (var targ in type.genericArguments) {
                        if (!checkCircleValueType(targ)) {
                            return false;
                        }
                    }
                }

            }

            return true;
        }

    }

    /// <summary>
    /// 表示一个方法或属性定义。
    /// </summary>
    public abstract partial class MethodOrPropertyDefinition {

        /// <summary>
        /// 将当前成员引用添加到父容器。
        /// </summary>
        protected new void addReferenceToContainer() {

            // 不含显式接口，直接添加。
            if (explicitType == null) {
                base.addReferenceToContainer();
                return;
            }

            var member = reference;
            var c = container.reference;

            // 绑定源。
            member.definition = this;

            // 由于显式接口仍未解析，暂时无法添加显式接口成员。
            member.container = c;

            if (c.memberType != MemberType.@class && c.memberType != MemberType.@struct) {
                Compiler.error(ErrorCode.none, String.Format("“{0}”：只有类或结构成员才能显式声明接口", member.signature), explicitType);
            }

            checkUnexpectedModifiers(~Modifiers.none, "显式接口成员");
        }

        #region 修饰符

        /// <summary>
        /// 检查 virtual 相关修饰符是否合法。
        /// </summary>
        protected void checkVirtual() {

            if (modifiers.hasFlag(Modifiers.@static) && modifiers.hasFlag(Modifiers.@virtual | Modifiers.@abstract | Modifiers.@override)) {
                base.reportMemberError(ErrorCode.none, "已标记为“static”的方法或属性不能同时标记为“virtual”、“abstract”或“override”；应删除“static”修饰符");
            } else if (modifiers.hasFlag(Modifiers.@virtual) && modifiers.hasFlag(Modifiers.@abstract | Modifiers.@override | Modifiers.@new)) {
                base.reportMemberError(ErrorCode.none, "已标记为“virtual”的方法或属性不能同时标记为“abstract”、“override”或“new”；应删除“virtual”修饰符");
            } else if (modifiers.hasFlag(Modifiers.@abstract) && modifiers.hasFlag(Modifiers.@override | Modifiers.@extern | Modifiers.@new)) {
                base.reportMemberError(ErrorCode.none, "已标记为“abstract”的方法或属性不能同时标记为“static”、“override”、“extern”或“new”；应删除“abstract”修饰符");
            } else if (modifiers.hasFlag(Modifiers.@override) && modifiers.hasFlag(Modifiers.@new)) {
                base.reportMemberError(ErrorCode.none, "已标记为“override”的方法或属性不能同时标记为“new”；如需重写成员，应删除“new”修饰符，否则应删除“override”修饰符");
            }

            if (modifiers.hasFlag(Modifiers.@private) && modifiers.hasFlag(Modifiers.@virtual | Modifiers.@abstract | Modifiers.@override)) {
                base.reportMemberError(ErrorCode.none, "已标记为“virtual”、“abstract”或“override”的方法或属性不能是私有的；应删除“private”修饰符");
            }

            if (modifiers.hasFlag(Modifiers.final) && !modifiers.hasFlag(Modifiers.@override)) {
                base.reportMemberError(ErrorCode.none, "只有标记为“override”的方法或属性才能标记为“final”；应删除“final”修饰符");
            }

        }

        /// <summary>
        /// 检查 override 修饰符是否正确使用。
        /// </summary>
        protected void checkOverride() {
            switch (reference.container.memberType) {
                case MemberType.@class:
                    var containerType = reference.containerType;

                    // 先从父类找到覆盖成员。
                    var baseMemberFound = containerType != null && containerType.baseClass != null ? containerType.baseClass.getOverrideingMember(reference) : null;
                    if (baseMemberFound != null && !baseMemberFound.modifiers.hasFlag(Modifiers.@private)) {

                        // 是否是重写成员。
                        if (reference.modifiers.hasFlag(Modifiers.@override)) {

                            // 确保父成员也是虚函数。
                            if (!baseMemberFound.modifiers.hasFlag(Modifiers.@override | Modifiers.@virtual | Modifiers.@abstract)) {
                                Compiler.error(ErrorCode.none, String.Format("父类成员“{0}”不是虚成员，子类成员不能使用“override”；请为父类成员添加“virtual”修饰符或为子类成员添加“new”修饰符", baseMemberFound.signature), name);
                                break;
                            }

                            // 确保父成员不是最终的。
                            if (baseMemberFound.modifiers.hasFlag(Modifiers.@final)) {
                                Compiler.error(ErrorCode.none, String.Format("父类成员“{0}”已标记“final”，子类成员不能使用“override”；请删除父类的“final”修饰符", baseMemberFound.signature), name);
                                break;
                            }

                            // 确保访问权限一致。
                            if ((reference.modifiers & (Modifiers.@protected | Modifiers.@private)) != (baseMemberFound.modifiers & (Modifiers.@protected | Modifiers.@private))) {
                                Compiler.error(ErrorCode.none, String.Format("重写成员时无法更改访问权限；应使用“{0}”", baseMemberFound.modifiers.getAccessibility().getName()), name);
                                break;
                            }

                            // 确保函数重载正确。
                            if (baseMemberFound is MethodReference) {
                                var thisMember = (MethodReference)reference;
                                var baseMember = (MethodReference)baseMemberFound;

                                // 确保返回值一致。
                                if (!ResolveHelper.isOverriding(thisMember.returnType, baseMember.returnType)) {
                                    Compiler.error(ErrorCode.none, String.Format("重写成员时无法更改返回类型；应返回“{0}”", baseMember.returnType.signature), returnType);
                                    break;
                                }

                                // 确保泛型参数一致。
                                int r = ResolveHelper.checkOverridingGenericTypeParameterConstraints(thisMember, baseMember);
                                if (r >= 0) {
                                    var p = ((MethodDefinition)this).genericParameters;
                                    while (r-- > 0)
                                        p = p.next;
                                    Compiler.error(ErrorCode.none, "重写成员时无法更改泛型约束", p.name);
                                    return;
                                }

                                break;
                            }

                            // 确保属性重载正确。
                            if (baseMemberFound is PropertyReference) {
                                var thisMember = (PropertyReference)reference;
                                var baseMember = (PropertyReference)baseMemberFound;

                                // 确保返回值一致。
                                if (!ResolveHelper.isOverriding(thisMember.returnType, baseMember.returnType)) {
                                    Compiler.error(ErrorCode.none, String.Format("重写成员时无法更改返回类型；应返回“{0}”", baseMember.returnType.signature), returnType);
                                    return;
                                }

                                checkAccessorOverload(thisMember.getAccessor, baseMember.getAccessor);
                                checkAccessorOverload(thisMember.setAccessor, baseMember.setAccessor);

                            }

                            break;
                        }

                        // 不允许覆盖抽象的成员。
                        if (baseMemberFound.modifiers.hasFlag(Modifiers.@abstract)) {
                            Compiler.error(ErrorCode.none, String.Format(reference.modifiers.hasFlag(Modifiers.@new) ? "无法覆盖抽象成员“{0}”；是否缺少“override”?" : "无法覆盖抽象成员“{0}”；是否将“override”写成“new”?", baseMemberFound.signature), name);
                            break;
                        }

                        if (!reference.modifiers.hasFlag(Modifiers.@new)) {
                            Compiler.warning(ErrorCode.none, String.Format(baseMemberFound.modifiers.hasFlag(Modifiers.@override | Modifiers.@virtual) ? "“{0}”覆盖了继承的成员“{1}”；如果需要重写父成员，应使用“override”修饰符" : "“{0}”覆盖了继承的成员“{1}”；如果需要重写而不是覆盖，请为父类成员添加“virtual”修饰符并为当前成员添加“override”修饰符；如果是有意覆盖，请添加“new”修饰符", reference.signature, baseMemberFound.signature), name);
                        }

                        break;
                    }

                    // 不存在父类覆盖情况。
                    if (reference.modifiers.hasFlag(Modifiers.@override)) {
                        Compiler.error(ErrorCode.none, String.Format("“{0}”并未重写成员，不需要“override”修饰符", reference.signature), name);
                    }

                    if (reference.modifiers.hasFlag(Modifiers.@new)) {
                        Compiler.warning(ErrorCode.none, String.Format("“{0}”并未覆盖继承的成员，不需要“new”修饰符", reference.signature), name);
                    }
                    break;
                case MemberType.@interface:

                    //// 允许接口默认实现直接覆盖继承的成员。
                    //if (reference.modifiers.hasFlag(Modifiers.@abstract) && reference.containerType.baseInterfaces != null) {
                    //    foreach (var implementedType in reference.parentType.implementedTypes) {
                    //        var bas = implementedType.getSameNonPrivateMember(reference);
                    //        if (bas != null) {
                    //            Compiler.warning(ErrorCode.none, String.Format("{0}覆盖了继承的{2}“{1}”", reference.signature, bas.signature, bas.memberType.getReadableName()), name);
                    //            break;
                    //        }
                    //    }
                    //}

                    break;
                //    case MemberType.extension:
                //        var baseMemberFound2 = ((ExtensionReference)reference.parentContainer).targetType.getSameNonPrivateMember(reference);
                //        if (baseMemberFound2 != null) {
                //            Compiler.error(ErrorCode.none, String.Format("无法通过扩展覆盖“{0}”", baseMemberFound2.signature), name);
                //        }
                //        break;
            }

        }

        private static void checkAccessorOverload(MethodReference thisAccessor, MethodReference baseAccessor) {
            if (baseAccessor != null) {
                if (thisAccessor != null && (thisAccessor.modifiers & (Modifiers.@protected | Modifiers.@private)) != (baseAccessor.modifiers & (Modifiers.@protected | Modifiers.@private))) {
                    Compiler.error(ErrorCode.none, String.Format("重写成员时无法更改访问权限；应使用“{0}”", baseAccessor.modifiers.getName()), thisAccessor.definition.name);
                }
            } else if (thisAccessor != null) {
                Compiler.error(ErrorCode.none, String.Format("无法重写 {0} 访问器；基类成员不存在 {0} 访问器", thisAccessor.name), thisAccessor.definition.name);
            }
        }

        #endregion

        #region 显式接口声明

        /// <summary>
        /// 解析显示声明的所属接口类型是否有效。
        /// </summary>
        protected void resolveExplicitType() {

            // 并不是所有成员都有显式接口。
            if (explicitType == null) {
                return;
            }

            // 解析显式接口类型。
            var resolved = explicitType.resolveAsType(this, MemberUsage.explicitType);
            if (resolved == null) {
                return;
            }

            // 只能显式声明接口。
            if (resolved.memberType != MemberType.@interface) {
                if (resolved.memberType == MemberType.specailType) {
                    Compiler.error(ErrorCode.expectedInterfaceType, String.Format("“{0}”在此处无效", resolved.signature), explicitType);
                } else {
                    Compiler.error(ErrorCode.expectedInterfaceType, String.Format("应输入接口类型；“{0}”是{1}，不是接口", resolved.signature, resolved.memberType.getReadableName()), explicitType);
                }
                return;
            }

            var exist = reference.containerType.addExplicitMember(resolved, reference);

            // 不允许出现同名且有相同泛型参数个数的成员。
            if (exist != null) {
                for (var c = reference; exist != c; exist = exist.next) {
                    if (exist.isOverriding(c)) {
                        Compiler.error(ErrorCode.none, String.Format(c.genericParameters == null ? "{0}“{1}”已包含名为“{2}”的{3}定义" : "{0}“{1}”已包含名为“{2}”且具有相同泛型参数的{3}定义", reference.container.memberType.getReadableName(), reference.container.signature, name.value, exist.memberType.getReadableName()), name);
                        break;
                    }
                }
            }

        }

        /// <summary>
        /// 检验显示接口声明的合法性。
        /// </summary>
        protected void checkExplicitType() {

            if (explicitType == null) {
                checkOverride();
                return;
            }

            var t = explicitType.resolveAsType(this, MemberUsage.explicitType);

            // 在 resolveExplicitType 中已经解析过并确认是可以解析的。
            Debug.Assert(t != null);

            // 在当前类型的继承列表中，应该包含所属接口。
            if (!reference.containerType.getAllRequiredTypes().Contains(t)) {
                Compiler.error(ErrorCode.explicitTypeNotFound, String.Format("接口“{0}”并未包含在所属类型的继承列表中", t.signature), explicitType);
                return;
            }

            // 接口类型中必须直接包含指定的类型成员。
            // 这里不检查成员的实现是否完全符合基类要求，等待检查接口实现时再处理。
            if (t.getOverrideingMemberFromThis(name.value, reference) == null) {
                if (reference.memberType.isOverloadable()) {
                    Compiler.error(ErrorCode.explicitTypeMemberNotFound, String.Format("接口“{0}”不直接存在名为“{1}”且具有相同参数的成员", t.signature, name), explicitType);
                } else {
                    Compiler.error(ErrorCode.explicitTypeMemberNotFound, String.Format("接口“{0}”不直接存在名为“{1}”的成员", t.signature, name), explicitType);
                }
                return;
            }

        }

        #endregion

        /// <summary>
        /// 判断当前成员是否是接口成员。
        /// </summary>
        public bool isInterfaceMember {
            get { return container.reference.memberType == MemberType.@interface; }
        }

        protected override void checkAnnotation(MemberDefinition.MemberAnnotation annotation) {
            base.checkAnnotation(annotation);

            //@dllImport
            //if (a.Type == pa.DllImport) {
            //    const Modifiers extern_static = Modifiers.@extern | Modifiers.@static;
            //    if ((ModFlags & extern_static) != extern_static) {
            //        Compiler.Report.Error(601, a.Location, "The DllImport attribute must be specified on a method marked `static' and `extern'");
            //    }

            //    if (MemberName.IsGeneric || containerType.IsGenericOrParentIsGeneric) {
            //        Compiler.Report.Error(7042, a.Location,
            //            "The DllImport attribute cannot be applied to a method that is generic or contained in a generic type");
            //    }

            //    is_external_implementation = true;
            //}


        }

    }

    /// <summary>
    /// 表示一个属性或索引器定义。
    /// </summary>
    public abstract partial class PropertyOrIndexerDefinition {

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public new PropertyReference reference {
            get {
                return (PropertyReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 表示一个属性访问器。
        /// </summary>
        public partial class PropertyAccessor {

            /// <summary>
            /// 获取当前访问器所在的属性。
            /// </summary>
            public PropertyOrIndexerDefinition parentMember;

            /// <summary>
            /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
            /// </summary>
            public sealed override void defineMember() {

                var member = reference = new MethodReference(MemberType.method);
                member.name = parentMember.name.value + "." + name.value;
                member.container = reference.container;

                // 检查修饰符。
                if (modifiers == Modifiers.none) {
                    member.modifiers = parentMember.modifiers;
                } else {
                    if (parentMember.reference.modifiers.hasFlag(modifiers == Modifiers.@private ? Modifiers.@private : (Modifiers.@private | Modifiers.@protected))) {
                        Compiler.error(ErrorCode.none, String.Format("“{0}”访问器的访问权限不能高于所在属性", name.value), name);
                    }

                    if (parentMember.getAccessor == null || parentMember.setAccessor == null) {
                        Compiler.error(ErrorCode.none, "仅当同时存在 get 和 set 访问器时才能单独设置访问器的访问权限", name);
                    }

                    member.modifiers = (parentMember.modifiers & ~Modifiers.ACCESSIBILITY) | modifiers;
                }
                base.checkModifiers();
                base.checkAbstractAndExtern(body);

            }

            /// <summary>
            /// 解析当前成员相关的类型引用。
            /// </summary>
            public sealed override void resolveMember() {
                base.resolveAnnotations();
            }

            /// <summary>
            /// 解析当前成员的主体。
            /// </summary>
            public sealed override void resolveBody() {

                base.checkAnnotations();

                //if (getAccessor != null) {
                //    getAccessor.body.resolve(ResolveHelper.createResolveContext(this), propertyReference.returnType, null, null);
                //}

                //if (setAccessor != null) {
                //    setAccessor.body.resolve(ResolveHelper.createResolveContext(this), PredefinedTypes.@void, new Parameter() {
                //        name = new Identifier() {
                //            value = "value"
                //        },
                //        resolvedType = propertyReference.returnType
                //    }, null);
                //}

            }

        }

        /// <summary>
        /// 检查主体是否符合 absract/extern 要求。
        /// </summary>
        /// <param name="propertyDefinition">要处理的成员定义。</param>
        public static void checkPropertyBody(PropertyDefinition propertyDefinition) {

            //// 接口成员特殊处理。
            //if (propertyDefinition.reference.parentContainer.memberType == MemberType.@interface) {

            //    // 保证两个访问器的主体一致。
            //    if (propertyDefinition.getAccessor != null && propertyDefinition.setAccessor != null && (propertyDefinition.getAccessor.body != null) != (propertyDefinition.setAccessor.body != null)) {
            //        if (propertyDefinition.getAccessor.body != null) {
            //            Compiler.error(ErrorCode.none, "在有默认实现时，必须同时提供 get 访问器和 set 访问器的默认实现", propertyDefinition.setAccessor);
            //        } else {
            //            Compiler.error(ErrorCode.none, "在有默认实现时，必须同时提供 get 访问器和 set 访问器的默认实现", propertyDefinition.getAccessor);
            //        }
            //    }

            //    if (propertyDefinition.getAccessor != null) {
            //        if (propertyDefinition.getAccessor.modifiers != Modifiers.none) {
            //            Compiler.error(ErrorCode.none, "接口内的成员不允许使用任何修饰符", propertyDefinition.getAccessor);
            //        }
            //        propertyDefinition.propertyReference.getAccessibility = Modifiers.@public;
            //    }

            //    if (propertyDefinition.setAccessor != null) {
            //        if (propertyDefinition.setAccessor.modifiers != Modifiers.none) {
            //            Compiler.error(ErrorCode.none, "接口内的成员不允许使用任何修饰符", propertyDefinition.setAccessor);
            //        }
            //        propertyDefinition.propertyReference.setAccessibility = Modifiers.@public;
            //    }

            //    propertyDefinition.reference.modifiers |= (propertyDefinition.getAccessor != null ? propertyDefinition.getAccessor.body == null : propertyDefinition.setAccessor == null || propertyDefinition.setAccessor.body == null) ? Modifiers.@abstract : Modifiers.@virtual;

            //    return;
            //}

            //// 检查是否存在主体。
            //if (propertyDefinition.modifiers.hasFlag(Modifiers.@abstract)) {
            //    if (propertyDefinition.getAccessor != null && propertyDefinition.getAccessor.body != null) {
            //        Compiler.error(ErrorCode.none, "标记为“abstract”的属性不能有主体", propertyDefinition.getAccessor);
            //    }
            //    if (propertyDefinition.setAccessor != null && propertyDefinition.setAccessor.body != null) {
            //        Compiler.error(ErrorCode.none, "标记为“abstract”的属性不能有主体", propertyDefinition.setAccessor);
            //    }
            //} else {
            //    if (propertyDefinition.getAccessor != null && propertyDefinition.getAccessor.body == null) {
            //        Compiler.error(ErrorCode.none, "缺少主体的属性必须标记为“abstract”", propertyDefinition.getAccessor);
            //    }
            //    if (propertyDefinition.setAccessor != null && propertyDefinition.setAccessor.body == null) {
            //        Compiler.error(ErrorCode.none, "缺少主体的属性必须标记为“abstract”", propertyDefinition.setAccessor);
            //    }
            //}

            //// 判断独立的访问器权限。
            //if (propertyDefinition.getAccessor == null || propertyDefinition.setAccessor == null) {
            //    if (propertyDefinition.getAccessor != null && propertyDefinition.getAccessor.modifiers != Modifiers.none) {
            //        Compiler.error(ErrorCode.none, "仅当同时存在 get 和 set 访问器时才能单独设置访问器的访问权限", propertyDefinition.getAccessor);
            //    } else if (propertyDefinition.setAccessor != null && propertyDefinition.setAccessor.modifiers != Modifiers.none) {
            //        Compiler.error(ErrorCode.none, "仅当同时存在 get 和 set 访问器时才能单独设置访问器的访问权限", propertyDefinition.setAccessor);
            //    }

            //} else if (propertyDefinition.getAccessor.modifiers != Modifiers.none && propertyDefinition.setAccessor.modifiers != Modifiers.none) {
            //    Compiler.error(ErrorCode.none, "不能同时设置 get 和 set 访问器的访问权限", propertyDefinition.getAccessor);
            //} else {
            //    Modifiers prop = propertyDefinition.modifiers.getAccessibility();
            //    if (propertyAccessorNotAllowed(prop, propertyDefinition.getAccessor.modifiers)) {
            //        Compiler.error(ErrorCode.none, "访问器的访问权限必须低于所属属性的访问权限", propertyDefinition.getAccessor);
            //    } else if (propertyAccessorNotAllowed(prop, propertyDefinition.setAccessor.modifiers)) {
            //        Compiler.error(ErrorCode.none, "访问器的访问权限必须低于所属属性的访问权限", propertyDefinition.setAccessor);
            //    }
            //}

            //// 设置默认为 public
            //if (propertyDefinition.getAccessor != null) {
            //    propertyDefinition.propertyReference.getAccessibility = propertyDefinition.getAccessor.modifiers == Modifiers.none ? Modifiers.@public : propertyDefinition.getAccessor.modifiers;
            //}
            //if (propertyDefinition.setAccessor != null) {
            //    propertyDefinition.propertyReference.setAccessibility = propertyDefinition.setAccessor.modifiers == Modifiers.none ? Modifiers.@public : propertyDefinition.setAccessor.modifiers;
            //}
        }

        protected void defineAccessors() {

            if (getAccessor != null) {
                getAccessor.parentMember = this;
                getAccessor.defineMember();
                reference.next = getAccessor.reference;
            }

            if (setAccessor != null) {
                getAccessor.parentMember = this;
                setAccessor.defineMember();
                if (reference.next == null) {
                    reference.next = setAccessor.reference;
                } else {
                    reference.next.next = setAccessor.reference;
                }
            }

            // 确保 get set 访问器一致。
            if (getAccessor != null && setAccessor != null && getAccessor.modifiers != Modifiers.none || setAccessor.modifiers != Modifiers.none) {
                Compiler.error(ErrorCode.none, "不能同时设置 get 和 set 访问器的访问权限", name);
            }

        }

    }

    /// <summary>
    /// 表示一个属性定义。
    /// </summary>
    public partial class PropertyDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.property;
            }
        }

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        public sealed override void defineMember() {

            // 创建引用。
            var member = reference = new PropertyReference();
            member.modifiers = base.getModifiersWithDefaultAccessibility();
            member.name = name.value;
            base.addReferenceToContainer();

            // 检查合法性。
            if (container.reference.memberType == MemberType.@namespace) {
                base.reportMemberError(ErrorCode.unepectedProperty, "无法在全局范围定义属性");
            }

            // 检查修饰符。
            base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@new | Modifiers.final | Modifiers.@static | Modifiers.@override | Modifiers.@abstract | Modifiers.@virtual | Modifiers.@params), "属性");
            base.checkVirtual();
            base.checkParams();
            if (setAccessor == null && modifiers.hasFlag(Modifiers.@params)) {
                base.reportMemberError(ErrorCode.none, "不含“set”访问器的属性不能标记为“params”；应添加“set”访问器");
            }

            // 定义访问器。
            base.defineAccessors();
        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public sealed override void resolveMember() {

            // 解析注解。
            base.resolveAnnotations();

            // 解析返回类型。
            reference.returnType = base.resolveReturnType(returnType, true);

            // 解析显式类型声明。
            base.resolveExplicitType();

            if (getAccessor != null) {
                getAccessor.resolveMember();
            }

            if (setAccessor != null) {
                setAccessor.resolveMember();
            }

        }

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public override void resolveBody() {

            // 检查注解类型。
            base.checkAnnotations();

            // 检查返回值。
            reference.returnType.checkType(returnType);

            // 检查成员覆盖性。
            base.checkExplicitType();

            if (getAccessor != null) {
                getAccessor.resolveBody();
            }

            if (setAccessor != null) {
                setAccessor.resolveBody();
            }

        }

    }

    /// <summary>
    /// 表示一个索引器定义。
    /// </summary>
    public partial class IndexerDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.indexer;
            }
        }

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public new IndexerReference reference {
            get {
                return (IndexerReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        public override void defineMember() {
            var c = container.reference;
            if (c.memberType == MemberType.@namespace) {
                base.reportMemberError(ErrorCode.unepectedIndexer, "无法在全局范围定义索引器");
            }

            if (c.modifiers.hasFlag(Modifiers.@static)) {
                base.reportMemberError(ErrorCode.none, String.Format("无法在静态类“{0}”定义索引器", c.signature));
            }

            base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@new | Modifiers.final | Modifiers.@override | Modifiers.@abstract | Modifiers.@virtual), "索引器");
            base.checkModifiers();

            var member = new IndexerReference();
            member.modifiers = modifiers;
            member.name = "@[]";
            member.parameters = base.defineParameters(parameters);

            // todo
            // ResolveHelper.addMember(this, container, member, explicitType);

            //    ResolveHelper.checkPropertyBody(this);
        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public override void resolveMember() {
            base.resolveMember();
            base.resolveParameters(parameters);
        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public override void resolveBody() {

            // base.resolveBody();

            base.checkParameters(parameters);

        }

    }

    /// <summary>
    /// 表示一个方法或构造函数定义。
    /// </summary>
    public abstract partial class MethodOrConstructorDefinition : MethodOrPropertyDefinition, IMethodData, IMethodDefinition {

        /// <summary>
        /// 获取当前成员定义对应的引用。
        /// </summary>
        public new MethodReference reference {
            get {
                return (MethodReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

    }

    /// <summary>
    /// 表示一个方法定义。
    /// </summary>
    public partial class MethodDefinition {

        /// <summary>
        /// 指示当前方法正在实现的接口方法。
        /// </summary>
        public MethodReference implementing;

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.method;
            }
        }

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        public sealed override void defineMember() {

            // 生成引用。
            var member = reference = genericParameters == null ?
                new MethodReference(MemberType.method) :
                new GenericMethodDefinitionReference(base.defineGenericParameters(genericParameters));
            member.modifiers = base.getModifiersWithDefaultAccessibility();
            member.name = name.value;
            member.parameters = base.defineParameters(parameters);
            base.addReferenceToContainer();

            // 检查修饰符。
            base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@new | Modifiers.@static | Modifiers.final | Modifiers.@extern | Modifiers.@abstract | Modifiers.@virtual | Modifiers.@override), "方法");
            base.checkModifiers();
            base.checkVirtual();
            base.checkAbstractAndExtern(body);

        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public sealed override void resolveMember() {

            // 解析注解。
            base.resolveAnnotations();

            // 解析返回类型。
            reference.returnType = base.resolveReturnType(this.returnType, true);

            // 解析显式类型声明。
            base.resolveExplicitType();

            // 解析泛型参数。
            base.resolveGenericParameters(genericParameters);

            // 解析参数。
            base.resolveParameters(parameters);

            // 检查函数重载是否有效。
            base.checkOverload();

        }

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public sealed override void resolveBody() {

            // 检查注解类型。
            base.checkAnnotations();

            // 检查返回类型。
            reference.returnType.checkType(this.returnType);

            // 检查成员覆盖性。
            base.checkExplicitType();

            // 检查泛型参数。
            base.checkGenericParameters(genericParameters);

            // 检查方法参数。
            base.checkParameters(parameters);

            // 解析方法主体。
            base.resolveMethodBody(body, reference.returnType, parameters);

        }

    }

    /// <summary>
    /// 表示一个构造函数定义。
    /// </summary>
    public partial class ConstructorDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.constructor;
            }
        }

        /// <summary>
        /// 创建当前成员定义对应的引用。在创建引用前无法使用其它解析函数。
        /// </summary>
        /// <param name="container">要添加到的容器引用对象。</param>
        public sealed override void defineMember() {

            var isStatic = modifiers.hasFlag(Modifiers.@static);

            // 生成引用。
            var member = reference = new MethodReference(MemberType.constructor);
            member.modifiers = modifiers;
            member.name = isStatic ? "@sctor" : "@ctor";
            member.parameters = base.defineParameters(parameters);
            base.addReferenceToContainer();

            // 检查合法性。
            switch (container.reference.memberType) {
                case MemberType.@namespace:
                    base.reportMemberError(ErrorCode.unexpectedConstructor, "方法缺少返回类型");
                    break;
                case MemberType.@interface:
                    base.reportMemberError(ErrorCode.unexpectedConstructor, "接口不允许有构造方法");
                    break;
                case MemberType.extension:
                    base.reportMemberError(ErrorCode.unexpectedConstructor, "无法扩展构造方法");
                    break;
            }

            // 检查修饰符。
            base.checkUnexpectedModifiers(~(Modifiers.ACCESSIBILITY | Modifiers.@static), "构造方法");
            base.checkModifiers();

            // 检查参数是否合法。
            if (parameters != null && isStatic) {
                base.reportMemberError(ErrorCode.unexpectedStaticConstructorArguments, "静态构造函数不允许有参数");
            } else if (parameters == null && container.reference.memberType == MemberType.@struct) {
                base.reportMemberError(ErrorCode.expectedStructConstructorArguments, "结构不允许有空参构造函数");
            }

            base.checkAbstractAndExtern(body);
        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public sealed override void resolveMember() {

            // 解析注解。
            base.resolveAnnotations();

            // 解析返回类型。
            reference.returnType = PredefinedTypes.@void;

            // 解析参数。
            base.resolveParameters(parameters);

            // 检测函数重载是否有效。
            base.checkOverload();

            // 不能和 new() 共存。
            if (reference.container.getMember("@new") != null) {
                Compiler.error(ErrorCode.none, "重载“new”操作符后不允许同时定义构造函数", name);
            }

        }

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public sealed override void resolveBody() {

            // 检查注解类型。
            base.checkAnnotations();

            // 检查方法参数。
            base.checkParameters(parameters);

            // 解析方法主体。
            base.resolveMethodBody(body, reference.returnType, parameters);

        }

    }

    /// <summary>
    /// 表示操作符重载定义。
    /// </summary>
    public partial class OperatorDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.@operator;
            }
        }

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        public sealed override void defineMember() {

            // 生成引用。
            var member = reference = new MethodReference(MemberType.@operator);
            member.modifiers = modifiers;
            member.name = "@" + @operator.getName();
            base.addReferenceToContainer();

            // 检查合法性。
            var c = container.reference;
            if (c.memberType == MemberType.@namespace) {
                base.reportMemberError(ErrorCode.unexpectedConstructor, "无法在全局范围定义操作符重载");
            }
            if (c.modifiers.hasFlag(Modifiers.@static)) {
                base.reportMemberError(ErrorCode.none, String.Format("无法在静态类“{0}”定义操作符重载", c.signature));
            }

            // 检查修饰符。
            base.checkUnexpectedModifiers(@operator == TokenType.@as ? ~(Modifiers.@public | Modifiers.@static) : ~Modifiers.@public, "操作符重载");
            base.checkModifiers();
            base.checkAbstractAndExtern(body);

        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public sealed override void resolveMember() {

            // 解析注解。
            base.resolveAnnotations();

            // 解析返回类型。
            ((TypeMemberDefinition)this).reference.returnType = base.resolveReturnType(this.returnType, true);

            // 解析显示类型声明。
            base.resolveExplicitType();

            // 解析参数。
            base.resolveParameters(parameters);

            var method = reference;

            // as 操作符可能以返回值类型判断。
            if (@operator == TokenType.@as && !modifiers.hasFlag(Modifiers.@static)) {
                for (var c = method.container.getMember(method.name); c != method; c = c.next) {
                    if (method.returnType == ((MethodReference)c).returnType) {
                        Compiler.error(ErrorCode.none, String.Format("当前{0}下已存在名为“{1}”且返回相同类型的“as”操作符重载", method.container.memberType.getReadableName(), name.value), name);
                        break;
                    }
                }
            } else {

                // 检测函数重载是否有效。
                base.checkOverload();

            }

            // 检查操作符重载是否有效。
            switch (@operator) {
                case TokenType.@as:
                    if (modifiers.hasFlag(Modifiers.@static)) {
                        if (method.parameters.Length != 1) {
                            Compiler.error(ErrorCode.none, "重载“as”操作符且函数为静态时，必须有1个参数", name);
                            break;
                        }
                        if (method.returnType != method.container) {
                            Compiler.error(ErrorCode.none, "重载“as”操作符且函数为静态时，必须返回类型本身", name);
                            break;
                        }
                    } else if (method.parameters.Length != 0) {
                        Compiler.error(ErrorCode.none, "重载“as”操作符时，不能有参数", name);
                    }
                    break;

                case TokenType.@new:
                    if (!modifiers.hasFlag(Modifiers.@static)) {
                        Compiler.error(ErrorCode.none, "重载“new”操作符时应使用 static 修饰符", name);
                        break;
                    }
                    if (method.returnType != method.container) {
                        Compiler.error(ErrorCode.none, "重载“new”操作符时应返回所属类型本身", name);
                        break;
                    }
                    break;

                case TokenType.inc:
                case TokenType.dec:
                    if (method.parameters.Length != 0) {
                        Compiler.error(ErrorCode.none, "重载“++”或“--”操作符时，不能有参数", name);
                        break;
                    }
                    if (method.returnType != method.container) {
                        Compiler.error(ErrorCode.none, "重载“++”或“--”操作符时应返回所属类型本身", name);
                        break;
                    }
                    break;

                case TokenType.add:
                case TokenType.sub:
                    if (method.parameters.Length >= 2) {
                        Compiler.error(ErrorCode.none, String.Format("重载“{0}”操作符时应有 0 个或 1 个参数", @operator.getName()), name);
                        break;
                    }
                    break;
                case TokenType.mul:
                case TokenType.div:
                case TokenType.mod:
                case TokenType.pow:
                    if (method.parameters.Length != 1) {
                        Compiler.error(ErrorCode.none, String.Format("重载“{0}”操作符时应有 1 个参数", @operator.getName()), name);
                        break;
                    }
                    break;

                case TokenType.lt:
                case TokenType.lte:
                case TokenType.gt:
                case TokenType.gte:
                case TokenType.eq:
                case TokenType.ne:
                    if (method.returnType != PredefinedTypes.System_Bool) {
                        Compiler.error(ErrorCode.none, String.Format("重载“{0}”操作符时应返回“{1}”", @operator.getName(), PredefinedTypes.System_Bool.signature), name);
                    }
                    break;

                case TokenType.bitAnd:
                case TokenType.bitOr:
                case TokenType.bitShl:
                case TokenType.bitShr:
                case TokenType.bitXor:
                    if (method.parameters.Length != 1) {
                        Compiler.error(ErrorCode.none, String.Format("重载“{0}”操作符时应有 1 个参数", @operator.getName()), name);
                        break;
                    }
                    break;
                case TokenType.bitComplement:
                    if (method.parameters.Length != 0) {
                        Compiler.error(ErrorCode.none, "重载“%~”操作符时，不能有参数", name);
                        break;
                    }
                    if (method.returnType != method.container) {
                        Compiler.error(ErrorCode.none, "重载“%~”操作符时应返回所属类型本身", name);
                        break;
                    }
                    break;

                default:
                    throw new Unreachable();

            }

        }

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public sealed override void resolveBody() {

            //    // 检查操作符重载是否有效。
            //    switch (@operator) {
            //        case TokenType.@as:
            //            var fromType = modifiers.hasFlag(Modifiers.@static) ? methodReference.parameters[0].type : memberReference.parentType;
            //            var toType = methodReference.returnType;
            //            if (fromType.isAssignableFrom(toType)) {
            //                Compiler.error(ErrorCode.none, String.Format("无法定义转换为“{1}”的“as”操作符重载；已存在从“{1}”到“{0}”的隐式转换", fromType.signature, toType.signature), name);
            //            } else if (toType.isAssignableFrom(fromType)) {
            //                Compiler.error(ErrorCode.none, String.Format("无法定义转换为“{1}”的“as”操作符重载；已存在从“{0}”到“{1}”的隐式转换", fromType.signature, toType.signature), name);
            //            }
            //            break;
            //        case TokenType.@new:

            //        // 检查操作符重载完整性。

            //        case TokenType.inc:
            //            checkImplemention(TokenType.dec);
            //            break;
            //        case TokenType.dec:
            //            checkImplemention(TokenType.inc);
            //            break;
            //        case TokenType.add:
            //            checkImplemention(TokenType.sub);
            //            break;
            //        case TokenType.sub:
            //            checkImplemention(TokenType.add);
            //            break;

            //        case TokenType.mul:
            //            checkImplemention(TokenType.div);
            //            break;
            //        case TokenType.div:
            //            checkImplemention(TokenType.mul);
            //            break;
            //        case TokenType.mod:
            //        case TokenType.pow:
            //            break;

            //        case TokenType.lt:
            //            checkImplemention(TokenType.gt);
            //            break;
            //        case TokenType.lte:
            //            checkImplemention(TokenType.gte);
            //            break;
            //        case TokenType.gt:
            //            checkImplemention(TokenType.lt);
            //            break;
            //        case TokenType.gte:
            //            checkImplemention(TokenType.lte);
            //            break;
            //        case TokenType.eq:
            //            checkImplemention(TokenType.ne);
            //            break;
            //        case TokenType.ne:
            //            checkImplemention(TokenType.eq);
            //            break;

            //        case TokenType.bitAnd:
            //            checkImplemention(TokenType.bitOr);
            //            break;
            //        case TokenType.bitOr:
            //            checkImplemention(TokenType.bitAnd);
            //            break;
            //        case TokenType.bitShl:
            //            checkImplemention(TokenType.bitShr);
            //            break;
            //        case TokenType.bitShr:
            //            checkImplemention(TokenType.bitShl);
            //            break;
            //        case TokenType.bitXor:
            //        case TokenType.bitComplement:
            //            break;
            //    }

            //    base.resolveBody();
        }

        private void checkImplemention(TokenType other) {
            var exist = reference.containerType.getOverrideingMemberFromThis("@" + other.getName(), reference);
            if (exist != null) {
                return;
            }

            Compiler.error(ErrorCode.none, String.Format("重载“{0}”操作符时必须同时重载“{1}”操作符", @operator.getName(), other.getName()), name);
        }

    }

    /// <summary>
    /// 表示一个枚举的成员定义。
    /// </summary>
    public partial class EnumMemberDefinition {

        /// <summary>
        /// 获取当前定义对应的成员类型。
        /// </summary>
        protected sealed override MemberType memberType {
            get {
                return MemberType.field;
            }
        }

        /// <summary>
        /// 获取或设置当前枚举字段的引用。
        /// </summary>
        public new FieldReference reference {
            get {
                return (FieldReference)base.reference;
            }
            set {
                base.reference = value;
            }
        }

        /// <summary>
        /// 创建当前成员对应的引用。在创建引用前无法调用其它解析函数。
        /// </summary>
        /// <param name="container">引用所在的容器。</param>
        public sealed override void defineMember() {

            // 生成引用。
            var member = reference = new FieldReference();
            member.modifiers = Modifiers.@const;
            member.name = name.value;
            base.addReferenceToContainer();

            //if (em.Name == underlyingValueField) {
            //    Compiler.Report.Error(76, em.startLocation, "An item in an enumeration cannot have an identifier `{0}'",
            //        underlyingValueField);
            //    return;
            //}

        }

        /// <summary>
        /// 解析当前成员相关的类型引用。
        /// </summary>
        public override void resolveMember() {

            // 解析注解类型。
            base.resolveAnnotations();

            // 解析法返回类型。
            reference.returnType = reference.containerType;
        }

        /// <summary>
        /// 解析当前成员的主体。
        /// </summary>
        public override void resolveBody() {

            // 检查注解类型。
            base.checkAnnotations();

            var elementType = reference.containerType.baseClass.genericArguments[0];

            //    if (initializer != null) {
            //        var initializerValue = initializer.resolveAsValue(ResolveHelper.createResolveContext(this), elementType);
            //        fieldReference.initialValue = initializer as Constant;
            //        if (fieldReference.initialValue == null && initializerValue != null) {
            //            Compiler.error(ErrorCode.none, "无法在编译时计算枚举值", initializer);
            //            return;
            //        }
            //    } else {
            //        var lastItem = getLastEnumFieldValue();
            //        Constant value;
            //        switch (elementType.primitiveType) {
            //            case PrimitiveType.int32:
            //                value = Int32Constant.from(lastItem == null ? 0 : lastItem.int32Value + 1);
            //                break;
            //            case PrimitiveType.@byte:
            //            case PrimitiveType.int16:
            //            case PrimitiveType.uint16:
            //                value = new SmallIntConstant(elementType, lastItem == null ? 0 : lastItem.int32Value + 1);
            //                break;
            //            case PrimitiveType.uint32:
            //                value = UInt32Constant.from(lastItem == null ? 0U : lastItem.uint32Value + 1U);
            //                break;
            //            case PrimitiveType.int64:
            //                value = Int64Constant.from(lastItem == null ? 0L : lastItem.uint32Value + 1L);
            //                break;
            //            case PrimitiveType.uint64:
            //                value = UInt64Constant.from(lastItem == null ? 0UL : lastItem.uint64Value + 1UL);
            //                break;
            //            case PrimitiveType.float32:
            //                value = Float32Constant.from(lastItem == null ? 0f : lastItem.float32Value + 1f);
            //                break;
            //            case PrimitiveType.float64:
            //                value = Float64Constant.from(lastItem == null ? 0d : lastItem.float64Value + 1d);
            //                break;
            //            default:
            //                if (elementType == PredefinedTypes.System_String) {
            //                    value = new StringConstant(fieldReference.name);
            //                    break;
            //                }
            //                Compiler.error(ErrorCode.none, String.Format("当基础类型为“{0}”时，无法省略初始值", elementType.signature), name);
            //                value = null;
            //                break;
            //        }
            //        fieldReference.initialValue = value;
            //    }

        }

        ///// <summary>
        ///// 获取当前枚举字段的上一个字段。
        ///// </summary>
        ///// <returns></returns>
        //private Constant getLastEnumFieldValue() {
        //    var member = parentContainer.members;
        //    if (member == parentContainer.members) {
        //        return null;
        //    }

        //    for (; member != null; member = member.next) {
        //        if (member.next == this) {
        //            return (Constant)((FieldReference)member.memberReference).initialValue;
        //        }
        //    }

        //    return null;
        //}

    }

    #endregion

}
